Merge branch 'mesa'

2025-08-23 19:52:19 +00:00 · 2023-04-21 15:19:21 +02:00
parent bf481f0f88 302075a65d
commit 4e296e0cf1
113 changed files with 8457 additions and 12300 deletions
--- a/examples/complete.yml
+++ b/examples/complete.yml
@@ -1,27 +0,0 @@
---
-name: simple
-group: tests
-dir_path: "/tmp/"
-num_trials: 3
-max_time: 100
-interval: 1
-seed: "CompleteSeed!"
-network_params:
-  generator: complete_graph
-  n: 10
-network_agents:
-  - agent_type: CounterModel
-    weight: 1
-    state:
-      state_id: 0
-  - agent_type: AggregatedCounter
-    weight: 0.2
-environment_agents: []
-environment_class: Environment
-environment_params:
-  am_i_complete: true
-default_state:
-  incidents: 0
-states:
-  - name: 'The first node'
-  - name: 'The second node'
--- a/examples/custom_generator/custom_generator.yml
+++ b/examples/custom_generator/custom_generator.yml
@@ -1,16 +0,0 @@
---
-name: custom-generator
-description: Using a custom generator for the network
-num_trials: 3
-max_time: 100
-interval: 1
-network_params:
-  generator: mymodule.mygenerator
-# These are custom parameters
-  n: 10
-  n_edges: 5  
-network_agents:
-  - agent_type: CounterModel
-    weight: 1
-    state:
-      state_id: 0
--- a/examples/custom_generator/generator_sim.py
+++ b/examples/custom_generator/generator_sim.py
@@ -0,0 +1,39 @@
+from networkx import Graph
+import random
+import networkx as nx
+from soil import Simulation, Environment, CounterModel, parameters
+
+
+def mygenerator(n=5, n_edges=5):
+    """
+    Just a simple generator that creates a network with n nodes and
+    n_edges edges. Edges are assigned randomly, only avoiding self loops.
+    """
+    G = nx.Graph()
+
+    for i in range(n):
+        G.add_node(i)
+
+    for i in range(n_edges):
+        nodes = list(G.nodes)
+        n_in = random.choice(nodes)
+        nodes.remove(n_in)  # Avoid loops
+        n_out = random.choice(nodes)
+        G.add_edge(n_in, n_out)
+    return G
+
+
+class GeneratorEnv(Environment):
+    """Using a custom generator for the network"""
+
+    generator: parameters.function = staticmethod(mygenerator)
+
+    def init(self):
+        self.create_network(generator=self.generator, n=10, n_edges=5)
+        self.add_agents(CounterModel)
+
+
+sim = Simulation(model=GeneratorEnv, max_steps=10, interval=1)
+
+if __name__ == '__main__':
+    sim.run(dump=False)
--- a/examples/custom_generator/mymodule.py
+++ b/examples/custom_generator/mymodule.py
@@ -1,27 +0,0 @@
-from networkx import Graph
-import networkx as nx
-from random import choice
-
-def mygenerator(n=5, n_edges=5):
-    '''
-    Just a simple generator that creates a network with n nodes and
-    n_edges edges. Edges are assigned randomly, only avoiding self loops.
-    '''
-    G = nx.Graph()
-
-    for i in range(n):
-        G.add_node(i)
-    
-    for i in range(n_edges):
-        nodes = list(G.nodes)
-        n_in = choice(nodes)
-        nodes.remove(n_in)  # Avoid loops
-        n_out = choice(nodes)
-        G.add_edge(n_in, n_out)
-    return G
-    
-
-
-
-
-    
--- a/examples/custom_timeouts/custom_timeouts.py
+++ b/examples/custom_timeouts/custom_timeouts.py
@@ -1,35 +0,0 @@
-from soil.agents import FSM, state, default_state
-
-
-class Fibonacci(FSM):
-    '''Agent that only executes in t_steps that are Fibonacci numbers'''
-
-    defaults = {
-        'prev': 1
-    }
-
-    @default_state
-    @state
-    def counting(self):
-        self.log('Stopping at {}'.format(self.now))
-        prev, self['prev'] = self['prev'], max([self.now, self['prev']])
-        return None, self.env.timeout(prev)
-
-class Odds(FSM):
-    '''Agent that only executes in odd t_steps'''
-    @default_state
-    @state
-    def odds(self):
-        self.log('Stopping at {}'.format(self.now))
-        return None, self.env.timeout(1+self.now%2)
-
-if __name__ == '__main__':
-    import logging
-    logging.basicConfig(level=logging.INFO)
-    from soil import Simulation
-    s = Simulation(network_agents=[{'ids': [0], 'agent_type': Fibonacci},
-                                   {'ids': [1], 'agent_type': Odds}],
-                   network_params={"generator": "complete_graph", "n": 2},
-                   max_time=100,
-                   )
-    s.run(dry_run=True)
--- a/examples/custom_timeouts/custom_timeouts_sim.py
+++ b/examples/custom_timeouts/custom_timeouts_sim.py
@@ -0,0 +1,41 @@
+from soil.agents import FSM, state, default_state
+from soil.time import Delta
+
+
+class Fibonacci(FSM):
+    """Agent that only executes in t_steps that are Fibonacci numbers"""
+    prev = 1
+
+    @default_state
+    @state
+    def counting(self):
+        self.log("Stopping at {}".format(self.now))
+        prev, self["prev"] = self["prev"], max([self.now, self["prev"]])
+        return None, Delta(prev)
+
+
+class Odds(FSM):
+    """Agent that only executes in odd t_steps"""
+
+    @default_state
+    @state
+    def odds(self):
+        self.log("Stopping at {}".format(self.now))
+        return None, Delta(1 + self.now % 2)
+
+
+from soil import Environment, Simulation
+from networkx import complete_graph
+
+
+class TimeoutsEnv(Environment):
+    def init(self):
+        self.create_network(generator=complete_graph, n=2)
+        self.add_agent(agent_class=Fibonacci, node_id=0)
+        self.add_agent(agent_class=Odds, node_id=1)
+
+
+sim = Simulation(model=TimeoutsEnv, max_steps=10, interval=1)
+
+if __name__ == "__main__":
+    sim.run(dump=False)
--- a/examples/events_and_messages/README.md
+++ b/examples/events_and_messages/README.md
@@ -0,0 +1,9 @@
+This example can be run like with command-line options, like this:
+
+```bash
+python cars.py --level DEBUG  -e summary --csv
+#or
+soil cars.py -e summary
+```
+
+This will set the `CSV` (save the agent and model data to a CSV) and `summary` (print the a summary of the data to stdout) exporters, and set the log level to DEBUG.
--- a/examples/events_and_messages/cars_sim.py
+++ b/examples/events_and_messages/cars_sim.py
@@ -0,0 +1,231 @@
+"""
+This is an example of a simplified city, where there are Passengers and Drivers that can take those passengers
+from their location to their desired location.
+
+An example scenario could play like the following:
+
+- Drivers start in the `wandering` state, where they wander around the city until they have been assigned a journey
+- Passenger(1) tells every driver that it wants to request a Journey.
+- Each driver receives the request.
+  If Driver(2) is interested in providing the Journey, it asks Passenger(1) to confirm that it accepts Driver(2)'s request
+- When Passenger(1) accepts the request, two things happen:
+    - Passenger(1) changes its state to `driving_home`
+    - Driver(2) starts moving towards the origin of the Journey
+- Once Driver(2) reaches the origin, it starts moving itself and Passenger(1) to the destination of the Journey
+- When Driver(2) reaches the destination (carrying Passenger(1) along):
+    - Driver(2) starts wondering again
+    - Passenger(1) dies, and is removed from the simulation
+- If there are no more passengers available in the simulation, Drivers die
+"""
+from __future__ import annotations
+from typing import Optional
+from soil import *
+from soil import events
+from mesa.space import MultiGrid
+
+
+# More complex scenarios may use more than one type of message  between objects.
+# A common pattern is to use `enum.Enum` to represent state changes in a request.
+@dataclass
+class Journey:
+    """
+    This represents a request for a journey. Passengers and drivers exchange this object.
+
+    A journey may have a driver assigned or not. If the driver has not been assigned, this
+    object is considered a "request for a journey".
+    """
+
+    origin: (int, int)
+    destination: (int, int)
+    tip: float
+
+    passenger: Passenger
+    driver: Optional[Driver] = None
+
+
+class City(EventedEnvironment):
+    """
+    An environment with a grid where drivers and passengers will be placed.
+
+    The number of drivers and riders is configurable through its parameters:
+
+    :param str n_cars: The total number of drivers to add
+    :param str n_passengers: The number of passengers in the simulation
+    :param list agents: Specific agents to use in the simulation. It overrides the `n_passengers`
+    and `n_cars` params.
+    :param int height: Height of the internal grid
+    :param int width: Width of the internal grid
+    """
+    n_cars = 1
+    n_passengers = 10
+    height = 100
+    width = 100
+
+    def init(self):
+        self.grid = MultiGrid(width=self.width, height=self.height, torus=False)
+        if not self.agents:
+            self.add_agents(Driver, k=self.n_cars)
+            self.add_agents(Passenger, k=self.n_passengers)
+
+        for agent in self.agents:
+            self.grid.place_agent(agent, (0, 0))
+            self.grid.move_to_empty(agent)
+        
+        self.total_earnings = 0
+        self.add_model_reporter("total_earnings")
+
+    @report
+    @property
+    def number_passengers(self):
+        return self.count_agents(agent_class=Passenger)
+
+
+class Driver(Evented, FSM):
+    pos = None
+    journey = None
+    earnings = 0
+
+    def on_receive(self, msg, sender):
+        """This is not a state. It will run (and block) every time check_messages is invoked"""
+        if self.journey is None and isinstance(msg, Journey) and msg.driver is None:
+            msg.driver = self
+            self.journey = msg
+
+    def check_passengers(self):
+        """If there are no more passengers, stop forever"""
+        c = self.count_agents(agent_class=Passenger)
+        self.debug(f"Passengers left {c}")
+        if not c:
+            self.die("No more passengers")
+
+    @default_state
+    @state
+    def wandering(self):
+        """Move around the city until a journey is accepted"""
+        target = None
+        self.check_passengers()
+        self.journey = None
+        while self.journey is None:  # No potential journeys detected (see on_receive)
+            if target is None or not self.move_towards(target):
+                target = self.random.choice(
+                    self.model.grid.get_neighborhood(self.pos, moore=False)
+                )
+
+            self.check_passengers()
+            # This will call on_receive behind the scenes, and the agent's status will be updated
+            self.check_messages()
+            yield Delta(30)  # Wait at least 30 seconds before checking again
+
+        try:
+            # Re-send the journey to the passenger, to confirm that we have been selected
+            self.journey = yield self.journey.passenger.ask(self.journey, timeout=60)
+        except events.TimedOut:
+            # No journey has been accepted. Try again
+            self.journey = None
+            return
+
+        return self.driving
+
+    @state
+    def driving(self):
+        """The journey has been accepted. Pick them up and take them to their destination"""
+        self.info(f"Driving towards Passenger {self.journey.passenger.unique_id}")
+        while self.move_towards(self.journey.origin):
+            yield
+        self.info(f"Driving {self.journey.passenger.unique_id} from {self.journey.origin} to {self.journey.destination}")
+        while self.move_towards(self.journey.destination, with_passenger=True):
+            yield
+        self.info("Arrived at destination")
+        self.earnings += self.journey.tip
+        self.model.total_earnings += self.journey.tip
+        self.check_passengers()
+        return self.wandering
+
+    def move_towards(self, target, with_passenger=False):
+        """Move one cell at a time towards a target"""
+        self.debug(f"Moving { self.pos } -> { target }")
+        if target[0] == self.pos[0] and target[1] == self.pos[1]:
+            return False
+
+        next_pos = [self.pos[0], self.pos[1]]
+        for idx in [0, 1]:
+            if self.pos[idx] < target[idx]:
+                next_pos[idx] += 1
+                break
+            if self.pos[idx] > target[idx]:
+                next_pos[idx] -= 1
+                break
+        self.model.grid.move_agent(self, tuple(next_pos))
+        if with_passenger:
+            self.journey.passenger.pos = (
+                self.pos
+            )  # This could be communicated through messages
+        return True
+
+
+class Passenger(Evented, FSM):
+    pos = None
+
+    def on_receive(self, msg, sender):
+        """This is not a state. It will be run synchronously every time `check_messages` is run"""
+
+        if isinstance(msg, Journey):
+            self.journey = msg
+            return msg
+
+    @default_state
+    @state
+    def asking(self):
+        destination = (
+            self.random.randint(0, self.model.grid.height-1),
+            self.random.randint(0, self.model.grid.width-1),
+        )
+        self.journey = None
+        journey = Journey(
+            origin=self.pos,
+            destination=destination,
+            tip=self.random.randint(10, 100),
+            passenger=self,
+        )
+
+        timeout = 60
+        expiration = self.now + timeout
+        self.info(f"Asking for journey at: { self.pos }")
+        self.model.broadcast(journey, ttl=timeout, sender=self, agent_class=Driver)
+        while not self.journey:
+            self.debug(f"Waiting for responses at: { self.pos }")
+            try:
+                # This will call check_messages behind the scenes, and the agent's status will be updated
+                # If you want to avoid that, you can call it with: check=False
+                yield self.received(expiration=expiration)
+            except events.TimedOut:
+                self.info(f"Still no response. Waiting at: { self.pos }")
+                self.model.broadcast(
+                    journey, ttl=timeout, sender=self, agent_class=Driver
+                )
+                expiration = self.now + timeout
+        self.info(f"Got a response! Waiting for driver")
+        return self.driving_home
+
+    @state
+    def driving_home(self):
+        while (
+            self.pos[0] != self.journey.destination[0]
+            or self.pos[1] != self.journey.destination[1]
+        ):
+            try:
+                yield self.received(timeout=60)
+            except events.TimedOut:
+                pass
+
+        self.die("Got home safe!")
+
+
+simulation = Simulation(name="RideHailing",
+                        model=City,
+                        seed="carsSeed",
+                        max_time=1000,
+                        parameters=dict(n_passengers=2))
+
+if __name__ == "__main__":
+    easy(simulation)
--- a/examples/mesa/mesa.yml
+++ b/examples/mesa/mesa.yml
@@ -1,21 +0,0 @@
---
-name: mesa_sim
-group: tests
-dir_path: "/tmp"
-num_trials: 3
-max_time: 100
-interval: 1
-seed: '1'
-network_params:
-  generator: social_wealth.graph_generator
-  n: 5
-network_agents:
-  - agent_type: social_wealth.SocialMoneyAgent
-    weight: 1
-environment_class: social_wealth.MoneyEnv
-environment_params:
-  num_mesa_agents: 5
-  mesa_agent_type: social_wealth.MoneyAgent
-  N: 10
-  width: 50
-  height: 50
--- a/examples/mesa/mesa_sim.py
+++ b/examples/mesa/mesa_sim.py
@@ -0,0 +1,7 @@
+from soil import Simulation
+from social_wealth import MoneyEnv, graph_generator
+
+sim = Simulation(name="mesa_sim", dump=False, max_steps=10, interval=2, model=MoneyEnv, parameters=dict(generator=graph_generator, N=10, width=50, height=50))
+
+if __name__ == "__main__":
+    sim.run()
--- a/examples/mesa/server.py
+++ b/examples/mesa/server.py
@@ -1,7 +1,8 @@
 from mesa.visualization.ModularVisualization import ModularServer
-from soil.visualization import UserSettableParameter
+from mesa.visualization.UserParam import Slider, Choice
 from mesa.visualization.modules import ChartModule, NetworkModule, CanvasGrid
 from social_wealth import MoneyEnv, graph_generator, SocialMoneyAgent
+import networkx as nx


 class MyNetwork(NetworkModule):
@@ -13,15 +14,18 @@ def network_portrayal(env):
    # The model ensures there is 0 or 1 agent per node

    portrayal = dict()
+    wealths = {
+        node_id: data["agent"].wealth for (node_id, data) in env.G.nodes(data=True)
+    }
    portrayal["nodes"] = [
        {
-            "id": agent_id,
-            "size": env.get_agent(agent_id).wealth,
-            # "color": "#CC0000" if not agents or agents[0].wealth == 0 else "#007959",
-            "color": "#CC0000",
-            "label": f"{agent_id}: {env.get_agent(agent_id).wealth}",
+            "id": node_id,
+            "size": 2 * (wealth + 1),
+            "color": "#CC0000" if wealth == 0 else "#007959",
+            # "color": "#CC0000",
+            "label": f"{node_id}: {wealth}",
        }
-        for (agent_id) in env.G.nodes
+        for (node_id, wealth) in wealths.items()
    ]

    portrayal["edges"] = [
@@ -29,7 +33,6 @@ def network_portrayal(env):
        for edge_id, (source, target) in enumerate(env.G.edges)
    ]

-
    return portrayal


@@ -40,7 +43,7 @@ def gridPortrayal(agent):
    :param agent:  the agent in the simulation
    :return: the portrayal dictionary
    """
-    color = max(10, min(agent.wealth*10, 100))
+    color = max(10, min(agent.wealth * 10, 100))
    return {
        "Shape": "rect",
        "w": 1,
@@ -51,18 +54,17 @@ def gridPortrayal(agent):
        "Text": agent.unique_id,
        "x": agent.pos[0],
        "y": agent.pos[1],
-        "Color": f"rgba(31, 10, 255, 0.{color})"
+        "Color": f"rgba(31, 10, 255, 0.{color})",
    }


-grid = MyNetwork(network_portrayal, 500, 500, library="sigma")
+grid = MyNetwork(network_portrayal, 500, 500)
 chart = ChartModule(
    [{"Label": "Gini", "Color": "Black"}], data_collector_name="datacollector"
 )

-model_params = {
-    "N": UserSettableParameter(
-        "slider",
+parameters = {
+    "N": Slider(
        "N",
        5,
        1,
@@ -70,36 +72,40 @@ model_params = {
        1,
        description="Choose how many agents to include in the model",
    ),
-    "network_agents": [{"agent_type": SocialMoneyAgent}],
-    "height": UserSettableParameter(
-        "slider",
+    "height": Slider(
        "height",
        5,
        5,
        10,
        1,
        description="Grid height",
-        ),
-    "width": UserSettableParameter(
-        "slider",
+    ),
+    "width": Slider(
        "width",
        5,
        5,
        10,
        1,
        description="Grid width",
-        ),
-    "network_params": {
-        'generator': graph_generator
-    },
+    ),
+    "agent_class": Choice(
+        "Agent class",
+        value="MoneyAgent",
+        choices=["MoneyAgent", "SocialMoneyAgent"],
+    ),
+    "generator": graph_generator,
 }

-canvas_element = CanvasGrid(gridPortrayal, model_params["width"].value, model_params["height"].value, 500, 500)
+
+canvas_element = CanvasGrid(
+    gridPortrayal, parameters["width"].value, parameters["height"].value, 500, 500
+)


 server = ModularServer(
-    MoneyEnv, [grid, chart, canvas_element], "Money Model", model_params
+    MoneyEnv, [grid, chart, canvas_element], "Money Model", parameters
 )
 server.port = 8521

-server.launch(open_browser=False)
+if __name__ == '__main__':
+    server.launch(open_browser=False)
--- a/examples/mesa/social_wealth.py
+++ b/examples/mesa/social_wealth.py
@@ -1,23 +1,26 @@
-'''
+"""
 This is an example that adds soil agents and environment in a normal
 mesa workflow.
-'''
+"""
 from mesa import Agent as MesaAgent
 from mesa.space import MultiGrid
+
 # from mesa.time import RandomActivation
 from mesa.datacollection import DataCollector
 from mesa.batchrunner import BatchRunner

 import networkx as nx

-from soil import NetworkAgent, Environment
+from soil import NetworkAgent, Environment, serialization
+

 def compute_gini(model):
    agent_wealths = [agent.wealth for agent in model.agents]
    x = sorted(agent_wealths)
    N = len(list(model.agents))
-    B = sum( xi * (N-i) for i,xi in enumerate(x) ) / (N*sum(x))
-    return (1 + (1/N) - 2*B)
+    B = sum(xi * (N - i) for i, xi in enumerate(x)) / (N * sum(x))
+    return 1 + (1 / N) - 2 * B
+

 class MoneyAgent(MesaAgent):
    """
@@ -25,15 +28,14 @@ class MoneyAgent(MesaAgent):
    It will only share wealth with neighbors based on grid proximity
    """

-    def __init__(self, unique_id, model):
+    def __init__(self, unique_id, model, wealth=1, **kwargs):
        super().__init__(unique_id=unique_id, model=model)
-        self.wealth = 1
+        self.wealth = wealth

    def move(self):
        possible_steps = self.model.grid.get_neighborhood(
-            self.pos,
-            moore=True,
-            include_center=False)
+            self.pos, moore=True, include_center=False
+        )
        new_position = self.random.choice(possible_steps)
        self.model.grid.move_agent(self, new_position)

@@ -45,21 +47,21 @@ class MoneyAgent(MesaAgent):
            self.wealth -= 1

    def step(self):
-        self.info("Crying wolf", self.pos)
+        print("Crying wolf", self.pos)
        self.move()
        if self.wealth > 0:
            self.give_money()


-class SocialMoneyAgent(NetworkAgent, MoneyAgent):
+class SocialMoneyAgent(MoneyAgent, NetworkAgent):
    wealth = 1

    def give_money(self):
        cellmates = set(self.model.grid.get_cell_list_contents([self.pos]))
-        friends = set(self.get_neighboring_agents())
+        friends = set(self.get_neighbors())
        self.info("Trying to give money")
-        self.debug("Cellmates: ", cellmates)
-        self.debug("Friends: ", friends)
+        self.info("Cellmates: ", cellmates)
+        self.info("Friends: ", friends)

        nearby_friends = list(cellmates & friends)

@@ -69,14 +71,35 @@ class SocialMoneyAgent(NetworkAgent, MoneyAgent):
            self.wealth -= 1


+def graph_generator(n=5):
+    G = nx.Graph()
+    for ix in range(n):
+        G.add_edge(0, ix)
+    return G
+
+
 class MoneyEnv(Environment):
    """A model with some number of agents."""
-    def __init__(self, N, width, height, *args, network_params, **kwargs):

-        network_params['n'] = N
-        super().__init__(*args, network_params=network_params, **kwargs)
+    def __init__(
+        self,
+        width,
+        height,
+        N,
+        generator=graph_generator,
+        agent_class=SocialMoneyAgent,
+        topology=None,
+        **kwargs
+    ):
+
+        generator = serialization.deserialize(generator)
+        agent_class = serialization.deserialize(agent_class, globs=globals())
+        topology = generator(n=N)
+        super().__init__(topology=topology, N=N, **kwargs)
        self.grid = MultiGrid(width, height, False)

+        self.populate_network(agent_class=agent_class)
+
        # Create agents
        for agent in self.agents:
            x = self.random.randrange(self.grid.width)
@@ -84,37 +107,31 @@ class MoneyEnv(Environment):
            self.grid.place_agent(agent, (x, y))

        self.datacollector = DataCollector(
-            model_reporters={"Gini": compute_gini},
-            agent_reporters={"Wealth": "wealth"})
+            model_reporters={"Gini": compute_gini}, agent_reporters={"Wealth": "wealth"}
+        )


-def graph_generator(n=5):
-    G = nx.Graph()
-    for ix in range(n):
-        G.add_edge(0, ix)
-    return G
+if __name__ == "__main__":

-if __name__ == '__main__':
-
-
-    G = graph_generator()
-    fixed_params = {"topology": G,
-                    "width": 10,
-                    "network_agents": [{"agent_type": SocialMoneyAgent,
-                                       'weight': 1}],
-                    "height": 10}
+    fixed_params = {
+        "generator": nx.complete_graph,
+        "width": 10,
+        "network_agents": [{"agent_class": SocialMoneyAgent, "weight": 1}],
+        "height": 10,
+    }

    variable_params = {"N": range(10, 100, 10)}

-    batch_run = BatchRunner(MoneyEnv,
-                            variable_parameters=variable_params,
-                            fixed_parameters=fixed_params,
-                            iterations=5,
-                            max_steps=100,
-                            model_reporters={"Gini": compute_gini})
+    batch_run = BatchRunner(
+        MoneyEnv,
+        variable_parameters=variable_params,
+        fixed_parameters=fixed_params,
+        iterations=5,
+        max_steps=100,
+        model_reporters={"Gini": compute_gini},
+    )
    batch_run.run_all()

    run_data = batch_run.get_model_vars_dataframe()
    run_data.head()
    print(run_data.Gini)
-
--- a/examples/mesa/wealth.py
+++ b/examples/mesa/wealth.py
@@ -4,24 +4,26 @@ from mesa.time import RandomActivation
 from mesa.datacollection import DataCollector
 from mesa.batchrunner import BatchRunner

+
 def compute_gini(model):
    agent_wealths = [agent.wealth for agent in model.schedule.agents]
    x = sorted(agent_wealths)
    N = model.num_agents
-    B = sum( xi * (N-i) for i,xi in enumerate(x) ) / (N*sum(x))
-    return (1 + (1/N) - 2*B)
+    B = sum(xi * (N - i) for i, xi in enumerate(x)) / (N * sum(x))
+    return 1 + (1 / N) - 2 * B
+

 class MoneyAgent(Agent):
-    """ An agent with fixed initial wealth."""
+    """An agent with fixed initial wealth."""
+
    def __init__(self, unique_id, model):
        super().__init__(unique_id, model)
        self.wealth = 1

    def move(self):
        possible_steps = self.model.grid.get_neighborhood(
-            self.pos,
-            moore=True,
-            include_center=False)
+            self.pos, moore=True, include_center=False
+        )
        new_position = self.random.choice(possible_steps)
        self.model.grid.move_agent(self, new_position)

@@ -37,8 +39,10 @@ class MoneyAgent(Agent):
        if self.wealth > 0:
            self.give_money()

+
 class MoneyModel(Model):
    """A model with some number of agents."""
+
    def __init__(self, N, width, height):
        self.num_agents = N
        self.grid = MultiGrid(width, height, True)
@@ -55,29 +59,29 @@ class MoneyModel(Model):
            self.grid.place_agent(a, (x, y))

        self.datacollector = DataCollector(
-            model_reporters={"Gini": compute_gini},
-            agent_reporters={"Wealth": "wealth"})
+            model_reporters={"Gini": compute_gini}, agent_reporters={"Wealth": "wealth"}
+        )

    def step(self):
        self.datacollector.collect(self)
        self.schedule.step()


-if __name__ == '__main__':
+if __name__ == "__main__":

-    fixed_params = {"width": 10,
-                    "height": 10}
+    fixed_params = {"width": 10, "height": 10}
    variable_params = {"N": range(10, 500, 10)}

-    batch_run = BatchRunner(MoneyModel,
-                            variable_params,
-                            fixed_params,
-                            iterations=5,
-                            max_steps=100,
-                            model_reporters={"Gini": compute_gini})
+    batch_run = BatchRunner(
+        MoneyModel,
+        variable_params,
+        fixed_params,
+        iterations=5,
+        max_steps=100,
+        model_reporters={"Gini": compute_gini},
+    )
    batch_run.run_all()

    run_data = batch_run.get_model_vars_dataframe()
    run_data.head()
    print(run_data.Gini)
-
--- a/examples/newsspread/NewsSpread.ipynb
+++ b/examples/newsspread/NewsSpread.ipynb
@@ -80,11 +80,11 @@
      "max_time: 300\r\n",
      "name: Sim_all_dumb\r\n",
      "network_agents:\r\n",
-      "- agent_type: DumbViewer\r\n",
+      "- agent_class: DumbViewer\r\n",
      "  state:\r\n",
      "    has_tv: false\r\n",
      "  weight: 1\r\n",
-      "- agent_type: DumbViewer\r\n",
+      "- agent_class: DumbViewer\r\n",
      "  state:\r\n",
      "    has_tv: true\r\n",
      "  weight: 1\r\n",
@@ -104,19 +104,19 @@
      "max_time: 300\r\n",
      "name: Sim_half_herd\r\n",
      "network_agents:\r\n",
-      "- agent_type: DumbViewer\r\n",
+      "- agent_class: DumbViewer\r\n",
      "  state:\r\n",
      "    has_tv: false\r\n",
      "  weight: 1\r\n",
-      "- agent_type: DumbViewer\r\n",
+      "- agent_class: DumbViewer\r\n",
      "  state:\r\n",
      "    has_tv: true\r\n",
      "  weight: 1\r\n",
-      "- agent_type: HerdViewer\r\n",
+      "- agent_class: HerdViewer\r\n",
      "  state:\r\n",
      "    has_tv: false\r\n",
      "  weight: 1\r\n",
-      "- agent_type: HerdViewer\r\n",
+      "- agent_class: HerdViewer\r\n",
      "  state:\r\n",
      "    has_tv: true\r\n",
      "  weight: 1\r\n",
@@ -136,12 +136,12 @@
      "max_time: 300\r\n",
      "name: Sim_all_herd\r\n",
      "network_agents:\r\n",
-      "- agent_type: HerdViewer\r\n",
+      "- agent_class: HerdViewer\r\n",
      "  state:\r\n",
      "    has_tv: true\r\n",
      "    state_id: neutral\r\n",
      "  weight: 1\r\n",
-      "- agent_type: HerdViewer\r\n",
+      "- agent_class: HerdViewer\r\n",
      "  state:\r\n",
      "    has_tv: true\r\n",
      "    state_id: neutral\r\n",
@@ -163,12 +163,12 @@
      "max_time: 300\r\n",
      "name: Sim_wise_herd\r\n",
      "network_agents:\r\n",
-      "- agent_type: HerdViewer\r\n",
+      "- agent_class: HerdViewer\r\n",
      "  state:\r\n",
      "    has_tv: true\r\n",
      "    state_id: neutral\r\n",
      "  weight: 1\r\n",
-      "- agent_type: WiseViewer\r\n",
+      "- agent_class: WiseViewer\r\n",
      "  state:\r\n",
      "    has_tv: true\r\n",
      "  weight: 1\r\n",
@@ -189,12 +189,12 @@
      "max_time: 300\r\n",
      "name: Sim_all_wise\r\n",
      "network_agents:\r\n",
-      "- agent_type: WiseViewer\r\n",
+      "- agent_class: WiseViewer\r\n",
      "  state:\r\n",
      "    has_tv: true\r\n",
      "    state_id: neutral\r\n",
      "  weight: 1\r\n",
-      "- agent_type: WiseViewer\r\n",
+      "- agent_class: WiseViewer\r\n",
      "  state:\r\n",
      "    has_tv: true\r\n",
      "  weight: 1\r\n",
--- a/examples/newsspread/NewsSpread.yml
+++ b/examples/newsspread/NewsSpread.yml
@@ -1,138 +0,0 @@
---
-default_state: {}
-load_module: newsspread
-environment_agents: []
-environment_params:
-  prob_neighbor_spread: 0.0
-  prob_tv_spread: 0.01
-interval: 1
-max_time: 300
-name: Sim_all_dumb
-network_agents:
- agent_type: DumbViewer
-  state:
-    has_tv: false
-  weight: 1
- agent_type: DumbViewer
-  state:
-    has_tv: true
-  weight: 1
-network_params:
-  generator: barabasi_albert_graph
-  n: 500
-  m: 5
-num_trials: 50
---
-default_state: {}
-load_module: newsspread
-environment_agents: []
-environment_params:
-  prob_neighbor_spread: 0.0
-  prob_tv_spread: 0.01
-interval: 1
-max_time: 300
-name: Sim_half_herd
-network_agents:
- agent_type: DumbViewer
-  state:
-    has_tv: false
-  weight: 1
- agent_type: DumbViewer
-  state:
-    has_tv: true
-  weight: 1
- agent_type: HerdViewer
-  state:
-    has_tv: false
-  weight: 1
- agent_type: HerdViewer
-  state:
-    has_tv: true
-  weight: 1
-network_params:
-  generator: barabasi_albert_graph
-  n: 500
-  m: 5
-num_trials: 50
---
-default_state: {}
-load_module: newsspread
-environment_agents: []
-environment_params:
-  prob_neighbor_spread: 0.0
-  prob_tv_spread: 0.01
-interval: 1
-max_time: 300
-name: Sim_all_herd
-network_agents:
- agent_type: HerdViewer
-  state:
-    has_tv: true
-    state_id: neutral
-  weight: 1
- agent_type: HerdViewer
-  state:
-    has_tv: true
-    state_id: neutral
-  weight: 1
-network_params:
-  generator: barabasi_albert_graph
-  n: 500
-  m: 5
-num_trials: 50
---
-default_state: {}
-load_module: newsspread
-environment_agents: []
-environment_params:
-  prob_neighbor_spread: 0.0
-  prob_tv_spread: 0.01
-  prob_neighbor_cure: 0.1
-interval: 1
-max_time: 300
-name: Sim_wise_herd
-network_agents:
- agent_type: HerdViewer
-  state:
-    has_tv: true
-    state_id: neutral
-  weight: 1
- agent_type: WiseViewer
-  state:
-    has_tv: true
-  weight: 1
-network_params:
-  generator: barabasi_albert_graph
-  n: 500
-  m: 5
-num_trials: 50
---
-default_state: {}
-load_module: newsspread
-environment_agents: []
-environment_params:
-  prob_neighbor_spread: 0.0
-  prob_tv_spread: 0.01
-  prob_neighbor_cure: 0.1
-interval: 1
-max_time: 300
-name: Sim_all_wise
-network_agents:
- agent_type: WiseViewer
-  state:
-    has_tv: true
-    state_id: neutral
-  weight: 1
- agent_type: WiseViewer
-  state:
-    has_tv: true
-  weight: 1
-network_params:
-  generator: barabasi_albert_graph
-  n: 500
-  m: 5
-network_params:
-  generator: barabasi_albert_graph
-  n: 500
-  m: 5
-num_trials: 50
--- a/examples/newsspread/newsspread.py
+++ b/examples/newsspread/newsspread.py
@@ -1,86 +0,0 @@
-from soil.agents import FSM, state, default_state, prob
-import logging
-
-
-class DumbViewer(FSM):
-    '''
-    A viewer that gets infected via TV (if it has one) and tries to infect
-    its neighbors once it's infected.
-    '''
-    defaults = {
-        'prob_neighbor_spread': 0.5,
-        'prob_tv_spread': 0.1,
-    }
-
-    @default_state
-    @state
-    def neutral(self):
-        if self['has_tv']:
-            if prob(self.env['prob_tv_spread']):
-                return self.infected
-
-    @state
-    def infected(self):
-        for neighbor in self.get_neighboring_agents(state_id=self.neutral.id):
-            if prob(self.env['prob_neighbor_spread']):
-                neighbor.infect()
-
-    def infect(self):
-        '''
-        This is not a state. It is a function that other agents can use to try to
-        infect this agent. DumbViewer always gets infected, but other agents like
-        HerdViewer might not become infected right away
-        '''
-
-        self.set_state(self.infected)
-
-
-class HerdViewer(DumbViewer):
-    '''
-    A viewer whose probability of infection depends on the state of its neighbors.
-    '''
-
-    def infect(self):
-        '''Notice again that this is NOT a state. See DumbViewer.infect for reference'''
-        infected = self.count_neighboring_agents(state_id=self.infected.id)
-        total = self.count_neighboring_agents()
-        prob_infect = self.env['prob_neighbor_spread'] * infected/total
-        self.debug('prob_infect', prob_infect)
-        if prob(prob_infect):
-            self.set_state(self.infected)
-
-
-class WiseViewer(HerdViewer):
-    '''
-    A viewer that can change its mind.
-    '''
-
-    defaults = {
-        'prob_neighbor_spread': 0.5,
-        'prob_neighbor_cure': 0.25,
-        'prob_tv_spread': 0.1,
-    }
-
-    @state
-    def cured(self):
-        prob_cure = self.env['prob_neighbor_cure']
-        for neighbor in self.get_neighboring_agents(state_id=self.infected.id):
-            if prob(prob_cure):
-                try:
-                    neighbor.cure()
-                except AttributeError:
-                    self.debug('Viewer {} cannot be cured'.format(neighbor.id))
-
-    def cure(self):
-        self.set_state(self.cured.id)
-
-    @state
-    def infected(self):
-        cured = max(self.count_neighboring_agents(self.cured.id),
-                    1.0)
-        infected = max(self.count_neighboring_agents(self.infected.id),
-                       1.0)
-        prob_cure = self.env['prob_neighbor_cure'] * (cured/infected)
-        if prob(prob_cure):
-            return self.cured
-        return self.set_state(super().infected)
--- a/examples/newsspread/newsspread_sim.py
+++ b/examples/newsspread/newsspread_sim.py
@@ -0,0 +1,134 @@
+from soil.agents import FSM, NetworkAgent, state, default_state, prob
+from soil.parameters import *
+import logging
+
+from soil.environment import Environment
+
+
+class DumbViewer(FSM, NetworkAgent):
+    """
+    A viewer that gets infected via TV (if it has one) and tries to infect
+    its neighbors once it's infected.
+    """
+
+    has_been_infected: bool = False
+    has_tv: bool = False
+
+    @default_state
+    @state
+    def neutral(self):
+        if self.has_tv:
+            if self.prob(self.get("prob_tv_spread")):
+                return self.infected
+        if self.has_been_infected:
+            return self.infected
+
+    @state
+    def infected(self):
+        for neighbor in self.get_neighbors(state_id=self.neutral.id):
+            if self.prob(self.get("prob_neighbor_spread")):
+                neighbor.infect()
+
+    def infect(self):
+        """
+        This is not a state. It is a function that other agents can use to try to
+        infect this agent. DumbViewer always gets infected, but other agents like
+        HerdViewer might not become infected right away
+        """
+        self.has_been_infected = True
+
+
+class HerdViewer(DumbViewer):
+    """
+    A viewer whose probability of infection depends on the state of its neighbors.
+    """
+
+    def infect(self):
+        """Notice again that this is NOT a state. See DumbViewer.infect for reference"""
+        infected = self.count_neighbors(state_id=self.infected.id)
+        total = self.count_neighbors()
+        prob_infect = self.get("prob_neighbor_spread") * infected / total
+        self.debug("prob_infect", prob_infect)
+        if self.prob(prob_infect):
+            self.has_been_infected = True
+
+
+class WiseViewer(HerdViewer):
+    """
+    A viewer that can change its mind.
+    """
+
+    @state
+    def cured(self):
+        prob_cure = self.get("prob_neighbor_cure")
+        for neighbor in self.get_neighbors(state_id=self.infected.id):
+            if self.prob(prob_cure):
+                try:
+                    neighbor.cure()
+                except AttributeError:
+                    self.debug("Viewer {} cannot be cured".format(neighbor.id))
+
+    def cure(self):
+        self.has_been_cured = True
+
+    @state
+    def infected(self):
+        if self.has_been_cured:
+            return self.cured
+        cured = max(self.count_neighbors(self.cured.id), 1.0)
+        infected = max(self.count_neighbors(self.infected.id), 1.0)
+        prob_cure = self.get("prob_neighbor_cure") * (cured / infected)
+        if self.prob(prob_cure):
+            return self.cured
+
+
+class NewsSpread(Environment):
+    ratio_dumb: probability = 1,
+    ratio_herd: probability = 0,
+    ratio_wise: probability = 0,
+    prob_tv_spread: probability = 0.1,
+    prob_neighbor_spread: probability = 0.1,
+    prob_neighbor_cure: probability = 0.05,
+
+    def init(self):
+        self.populate_network([DumbViewer, HerdViewer, WiseViewer],
+                              [self.ratio_dumb, self.ratio_herd, self.ratio_wise])
+
+
+from itertools import product
+from soil import Simulation
+
+
+# We want to investigate the effect of different agent distributions on the spread of news.
+# To do that, we will run different simulations, with a varying ratio of DumbViewers, HerdViewers, and WiseViewers
+# Because the effect of these agents might also depend on the network structure, we will run our simulations on two different networks:
+# one with a small-world structure and one with a connected structure.
+
+counter = 0
+for [r1, r2] in product([0, 0.5, 1.0], repeat=2):
+    for (generator, netparams) in {
+        "barabasi_albert_graph": {"m": 5},
+        "erdos_renyi_graph": {"p": 0.1},
+    }.items():
+        print(r1, r2, 1-r1-r2, generator)
+        # Create new simulation
+        netparams["n"] = 500
+        Simulation(
+            name='newspread_sim',
+            model=NewsSpread,
+            parameters=dict(
+                ratio_dumb=r1,
+                ratio_herd=r2,
+                ratio_wise=1-r1-r2,
+                network_generator=generator,
+                network_params=netparams,
+                prob_neighbor_spread=0,
+            ),
+            iterations=5,
+            max_steps=300,
+            dump=False,
+        ).run()
+        counter += 1
+        # Run all the necessary instances
+ 
+print(f"A total of {counter} simulations were run.")
--- a/examples/programmatic/programmatic.py
+++ b/examples/programmatic/programmatic.py
@@ -1,40 +0,0 @@
-'''
-Example of a fully programmatic simulation, without definition files.
-'''
-from soil import Simulation, agents
-from networkx import Graph
-import logging
-
-
-def mygenerator():
-    # Add only a node
-    G = Graph()
-    G.add_node(1)
-    return G
-
-
-class MyAgent(agents.FSM):
-
-    @agents.default_state
-    @agents.state
-    def neutral(self):
-        self.debug('I am running')
-        if agents.prob(0.2):
-            self.info('This runs 2/10 times on average')
-
-
-s = Simulation(name='Programmatic',
-               network_params={'generator': mygenerator},
-               num_trials=1,
-               max_time=100,
-               agent_type=MyAgent,
-               dry_run=True)
-
-
-# By default, logging will only print WARNING logs (and above).
-# You need to choose a lower logging level to get INFO/DEBUG traces
-logging.basicConfig(level=logging.INFO)
-envs = s.run()
-
-# Uncomment this to output the simulation to a YAML file
-# s.dump_yaml('simulation.yaml')
--- a/examples/programmatic/programmatic_sim.py
+++ b/examples/programmatic/programmatic_sim.py
@@ -0,0 +1,53 @@
+"""
+Example of a fully programmatic simulation, without definition files.
+"""
+from soil import Simulation, Environment, agents
+from networkx import Graph
+import logging
+
+
+def mygenerator():
+    # Add only a node
+    G = Graph()
+    G.add_node(1)
+    G.add_node(2)
+    return G
+
+
+class MyAgent(agents.NetworkAgent, agents.FSM):
+    times_run = 0
+    @agents.default_state
+    @agents.state
+    def neutral(self):
+        self.debug("I am running")
+        if self.prob(0.2):
+            self.times_run += 1
+            self.info("This runs 2/10 times on average")
+
+
+class ProgrammaticEnv(Environment):
+
+    def init(self):
+        self.create_network(generator=mygenerator)
+        assert len(self.G)
+        self.populate_network(agent_class=MyAgent)
+        self.add_agent_reporter('times_run')
+
+
+simulation = Simulation(
+    name="Programmatic",
+    model=ProgrammaticEnv,
+    seed='Program',
+    iterations=1,
+    max_time=100,
+    dump=False,
+)
+
+if __name__ == "__main__":
+    # By default, logging will only print WARNING logs (and above).
+    # You need to choose a lower logging level to get INFO/DEBUG traces
+    logging.basicConfig(level=logging.INFO)
+    envs = simulation.run()
+
+    for agent in envs[0].agents:
+        print(agent.times_run)
--- a/examples/pubcrawl/pubcrawl.py
+++ b/examples/pubcrawl/pubcrawl.py
@@ -1,175 +0,0 @@
-from soil.agents import FSM, state, default_state
-from soil import Environment
-from random import random, shuffle
-from itertools import islice
-import logging
-
-
-class CityPubs(Environment):
-    '''Environment with Pubs'''
-    level = logging.INFO
-
-    def __init__(self, *args, number_of_pubs=3, pub_capacity=10, **kwargs):
-        super(CityPubs, self).__init__(*args, **kwargs)
-        pubs = {}
-        for i in range(number_of_pubs):
-            newpub = {
-                'name': 'The awesome pub #{}'.format(i),
-                'open': True,
-                'capacity': pub_capacity,
-                'occupancy': 0,
-            }
-            pubs[newpub['name']] = newpub
-        self['pubs'] = pubs
-
-    def enter(self, pub_id, *nodes):
-        '''Agents will try to enter. The pub checks if it is possible'''
-        try:
-            pub = self['pubs'][pub_id]
-        except KeyError:
-            raise ValueError('Pub {} is not available'.format(pub_id))
-        if not pub['open'] or (pub['capacity'] < (len(nodes) + pub['occupancy'])):
-            return False
-        pub['occupancy'] += len(nodes)
-        for node in nodes:
-            node['pub'] = pub_id
-        return True
-
-    def available_pubs(self):
-        for pub in self['pubs'].values():
-            if pub['open'] and (pub['occupancy'] < pub['capacity']):
-                yield pub['name']
-
-    def exit(self, pub_id, *node_ids):
-        '''Agents will notify the pub they want to leave'''
-        try:
-            pub = self['pubs'][pub_id]
-        except KeyError:
-            raise ValueError('Pub {} is not available'.format(pub_id))
-        for node_id in node_ids:
-            node = self.get_agent(node_id)
-            if pub_id == node['pub']:
-                del node['pub']
-                pub['occupancy'] -= 1
-
-
-class Patron(FSM):
-    '''Agent that looks for friends to drink with. It will do three things:
-        1) Look for other patrons to drink with
-        2) Look for a bar where the agent and other agents in the same group can get in.
-        3) While in the bar, patrons only drink, until they get drunk and taken home.
-    '''
-    level = logging.DEBUG
-
-    defaults = {
-        'pub': None,
-        'drunk': False,
-        'pints': 0,
-        'max_pints': 3,
-    }
-
-    @default_state
-    @state
-    def looking_for_friends(self):
-        '''Look for friends to drink with'''
-        self.info('I am looking for friends')
-        available_friends = list(self.get_agents(drunk=False,
-                                                 pub=None,
-                                                 state_id=self.looking_for_friends.id))
-        if not available_friends:
-            self.info('Life sucks and I\'m alone!')
-            return self.at_home
-        befriended = self.try_friends(available_friends)
-        if befriended:
-            return self.looking_for_pub
-
-    @state
-    def looking_for_pub(self):
-        '''Look for a pub that accepts me and my friends'''
-        if self['pub'] != None:
-            return self.sober_in_pub
-        self.debug('I am looking for a pub')
-        group = list(self.get_neighboring_agents())
-        for pub in self.env.available_pubs():
-            self.debug('We\'re trying to get into {}: total: {}'.format(pub, len(group)))
-            if self.env.enter(pub, self, *group):
-                self.info('We\'re all {} getting in {}!'.format(len(group), pub))
-                return self.sober_in_pub
-
-    @state
-    def sober_in_pub(self):
-        '''Drink up.'''
-        self.drink()
-        if self['pints'] > self['max_pints']:
-            return self.drunk_in_pub
-
-    @state
-    def drunk_in_pub(self):
-        '''I'm out. Take me home!'''
-        self.info('I\'m so drunk. Take me home!')
-        self['drunk'] = True
-        pass  # out drunk
-
-    @state
-    def at_home(self):
-        '''The end'''
-        others = self.get_agents(state_id=Patron.at_home.id, limit_neighbors=True)
-        self.debug('I\'m home. Just like {} of my friends'.format(len(others)))
-    
-    def drink(self):
-        self['pints'] += 1
-        self.debug('Cheers to that')
-    
-    def kick_out(self):
-        self.set_state(self.at_home)
-
-    def befriend(self, other_agent, force=False):
-        '''
-        Try to become friends with another agent. The chances of
-        success depend on both agents' openness.
-        '''
-        if force or self['openness'] > random():
-            self.env.add_edge(self, other_agent)
-            self.info('Made some friend {}'.format(other_agent))
-            return True
-        return False
-
-    def try_friends(self, others):
-        ''' Look for random agents around me and try to befriend them'''
-        befriended = False
-        k = int(10*self['openness'])
-        shuffle(others)
-        for friend in islice(others, k):  # random.choice >= 3.7
-            if friend == self:
-                continue
-            if friend.befriend(self):
-                self.befriend(friend, force=True)
-                self.debug('Hooray! new friend: {}'.format(friend.id))
-                befriended = True
-            else:
-                self.debug('{} does not want to be friends'.format(friend.id))
-        return befriended
-
-
-class Police(FSM):
-    '''Simple agent to take drunk people out of pubs.'''
-    level = logging.INFO
-
-    @default_state
-    @state
-    def patrol(self):
-        drunksters = list(self.get_agents(drunk=True,
-                                          state_id=Patron.drunk_in_pub.id))
-        for drunk in drunksters:
-            self.info('Kicking out the trash: {}'.format(drunk.id))
-            drunk.kick_out()
-        else:
-            self.info('No trash to take out. Too bad.')
-
-
-if __name__ == '__main__':
-    from soil import simulation
-    simulation.run_from_config('pubcrawl.yml',
-                               dry_run=True,
-                               dump=None,
-                               parallel=False)
--- a/examples/pubcrawl/pubcrawl.yml
+++ b/examples/pubcrawl/pubcrawl.yml
@@ -1,26 +0,0 @@
---
-name: pubcrawl
-num_trials: 3
-max_time: 10
-dump: false
-network_params:
-  # Generate 100 empty nodes. They will be assigned a network agent
-  generator: empty_graph
-  n: 30
-network_agents:
-  - agent_type: pubcrawl.Patron
-    description: Extroverted patron
-    state:
-      openness: 1.0
-    weight: 9
-  - agent_type: pubcrawl.Patron
-    description: Introverted patron
-    state:
-      openness: 0.1
-    weight: 1
-environment_agents:
-  - agent_type: pubcrawl.Police
-environment_class: pubcrawl.CityPubs
-environment_params:
-  altercations: 0
-  number_of_pubs: 3
--- a/examples/pubcrawl/pubcrawl_sim.py
+++ b/examples/pubcrawl/pubcrawl_sim.py
@@ -0,0 +1,195 @@
+from soil.agents import FSM, NetworkAgent, state, default_state
+from soil import Environment, Simulation, parameters
+from itertools import islice
+import networkx as nx
+import logging
+
+
+class CityPubs(Environment):
+    """Environment with Pubs"""
+
+    level = logging.INFO
+    number_of_pubs: parameters.Integer = 3
+    ratio_extroverted: parameters.probability = 0.1
+    pub_capacity: parameters.Integer = 10
+    
+    def init(self):
+        self.pubs = {}
+        for i in range(self.number_of_pubs):
+            newpub = {
+                "name": "The awesome pub #{}".format(i),
+                "open": True,
+                "capacity": self.pub_capacity,
+                "occupancy": 0,
+            }
+            self.pubs[newpub["name"]] = newpub
+        self.add_agent(agent_class=Police)
+        self.populate_network([Patron.w(openness=0.1), Patron.w(openness=1)],
+                              [self.ratio_extroverted, 1-self.ratio_extroverted])
+        assert all(["agent" in node and isinstance(node["agent"], Patron) for (_, node) in self.G.nodes(data=True)])
+
+    def enter(self, pub_id, *nodes):
+        """Agents will try to enter. The pub checks if it is possible"""
+        try:
+            pub = self["pubs"][pub_id]
+        except KeyError:
+            raise ValueError("Pub {} is not available".format(pub_id))
+        if not pub["open"] or (pub["capacity"] < (len(nodes) + pub["occupancy"])):
+            return False
+        pub["occupancy"] += len(nodes)
+        for node in nodes:
+            node["pub"] = pub_id
+        return True
+
+    def available_pubs(self):
+        for pub in self["pubs"].values():
+            if pub["open"] and (pub["occupancy"] < pub["capacity"]):
+                yield pub["name"]
+
+    def exit(self, pub_id, *node_ids):
+        """Agents will notify the pub they want to leave"""
+        try:
+            pub = self["pubs"][pub_id]
+        except KeyError:
+            raise ValueError("Pub {} is not available".format(pub_id))
+        for node_id in node_ids:
+            node = self.get_agent(node_id)
+            if pub_id == node["pub"]:
+                del node["pub"]
+                pub["occupancy"] -= 1
+
+
+class Patron(FSM, NetworkAgent):
+    """Agent that looks for friends to drink with. It will do three things:
+    1) Look for other patrons to drink with
+    2) Look for a bar where the agent and other agents in the same group can get in.
+    3) While in the bar, patrons only drink, until they get drunk and taken home.
+    """
+
+    level = logging.DEBUG
+
+    pub = None
+    drunk = False
+    pints = 0
+    max_pints = 3
+    kicked_out = False
+
+    @default_state
+    @state
+    def looking_for_friends(self):
+        """Look for friends to drink with"""
+        self.info("I am looking for friends")
+        available_friends = list(
+            self.get_agents(drunk=False, pub=None, state_id=self.looking_for_friends.id)
+        )
+        if not available_friends:
+            self.info("Life sucks and I'm alone!")
+            return self.at_home
+        befriended = self.try_friends(available_friends)
+        if befriended:
+            return self.looking_for_pub
+
+    @state
+    def looking_for_pub(self):
+        """Look for a pub that accepts me and my friends"""
+        if self["pub"] != None:
+            return self.sober_in_pub
+        self.debug("I am looking for a pub")
+        group = list(self.get_neighbors())
+        for pub in self.model.available_pubs():
+            self.debug("We're trying to get into {}: total: {}".format(pub, len(group)))
+            if self.model.enter(pub, self, *group):
+                self.info("We're all {} getting in {}!".format(len(group), pub))
+                return self.sober_in_pub
+
+    @state
+    def sober_in_pub(self):
+        """Drink up."""
+        self.drink()
+        if self["pints"] > self["max_pints"]:
+            return self.drunk_in_pub
+
+    @state
+    def drunk_in_pub(self):
+        """I'm out. Take me home!"""
+        self.info("I'm so drunk. Take me home!")
+        self["drunk"] = True
+        if self.kicked_out:
+            return self.at_home
+        pass  # out drun
+
+    @state
+    def at_home(self):
+        """The end"""
+        others = self.get_agents(state_id=Patron.at_home.id, limit_neighbors=True)
+        self.debug("I'm home. Just like {} of my friends".format(len(others)))
+
+    def drink(self):
+        self["pints"] += 1
+        self.debug("Cheers to that")
+
+    def kick_out(self):
+        self.kicked_out = True
+
+    def befriend(self, other_agent, force=False):
+        """
+        Try to become friends with another agent. The chances of
+        success depend on both agents' openness.
+        """
+        if force or self["openness"] > self.random.random():
+            self.add_edge(self, other_agent)
+            self.info("Made some friend {}".format(other_agent))
+            return True
+        return False
+
+    def try_friends(self, others):
+        """Look for random agents around me and try to befriend them"""
+        befriended = False
+        k = int(10 * self["openness"])
+        self.random.shuffle(others)
+        for friend in islice(others, k):  # random.choice >= 3.7
+            if friend == self:
+                continue
+            if friend.befriend(self):
+                self.befriend(friend, force=True)
+                self.debug("Hooray! new friend: {}".format(friend.unique_id))
+                befriended = True
+            else:
+                self.debug("{} does not want to be friends".format(friend.unique_id))
+        return befriended
+
+
+class Police(FSM):
+    """Simple agent to take drunk people out of pubs."""
+
+    level = logging.INFO
+
+    @default_state
+    @state
+    def patrol(self):
+        drunksters = list(self.get_agents(drunk=True, state_id=Patron.drunk_in_pub.id))
+        for drunk in drunksters:
+            self.info("Kicking out the trash: {}".format(drunk.unique_id))
+            drunk.kick_out()
+        else:
+            self.info("No trash to take out. Too bad.")
+
+
+sim = Simulation(
+    model=CityPubs,
+    name="pubcrawl",
+    iterations=3,
+    max_steps=10,
+    dump=False,
+    parameters=dict(
+        network_generator=nx.empty_graph,
+        network_params={"n": 30},
+        model=CityPubs,
+        altercations=0,
+        number_of_pubs=3,
+    )
+)
+
+
+if __name__ == "__main__":
+    sim.run(parallel=False)
--- a/examples/rabbits/README.md
+++ b/examples/rabbits/README.md
@@ -0,0 +1,14 @@
+There are two similar implementations of this simulation.
+
+- `basic`. Using simple primites
+- `improved`. Using more advanced features such as the `time` module to avoid unnecessary computations (i.e., skip steps), and generator functions.
+
+The examples can be run directly in the terminal, and they accept command like arguments.
+For example, to enable the CSV exporter and the Summary exporter, while setting `max_time` to `100` and `seed` to `CustomSeed`:
+
+```
+python rabbit_agents.py  --set max_time=100 --csv -e summary  --set 'seed="CustomSeed"'
+```
+
+To learn more about how this functionality works, check out the `soil.easy` function.
+
--- a/examples/rabbits/rabbit_agents.py
+++ b/examples/rabbits/rabbit_agents.py
@@ -1,135 +0,0 @@
-from soil.agents import FSM, state, default_state, BaseAgent, NetworkAgent
-from enum import Enum
-from random import random, choice
-import logging
-import math
-
-
-class Genders(Enum):
-    male = 'male'
-    female = 'female'
-
-
-class RabbitModel(FSM):
-
-    defaults = {
-        'age': 0,
-        'gender': Genders.male.value,
-        'mating_prob': 0.001,
-        'offspring': 0,
-    }
-
-    sexual_maturity = 3 #4*30
-    life_expectancy = 365 * 3
-    gestation = 33
-    pregnancy = -1
-    max_females = 5
-
-    @default_state
-    @state
-    def newborn(self):
-        self.debug(f'I am a newborn at age {self["age"]}')
-        self['age'] += 1
-
-        if self['age'] >= self.sexual_maturity:
-            self.debug('I am fertile!')
-            return self.fertile
-    @state
-    def fertile(self):
-        raise Exception("Each subclass should define its fertile state")
-
-    @state
-    def dead(self):
-        self.info('Agent {} is dying'.format(self.id))
-        self.die()
-
-
-class Male(RabbitModel):
-
-    @state
-    def fertile(self):
-        self['age'] += 1
-        if self['age'] > self.life_expectancy:
-            return self.dead
-
-        if self['gender'] == Genders.female.value:
-            return
-
-        # Males try to mate
-        for f in self.get_agents(state_id=Female.fertile.id,
-                                 agent_type=Female,
-                                 limit_neighbors=False,
-                                 limit=self.max_females):
-            r = random()
-            if r < self['mating_prob']:
-                self.impregnate(f)
-                break # Take a break
-    def impregnate(self, whom):
-        whom['pregnancy'] = 0
-        whom['mate'] = self.id
-        whom.set_state(whom.pregnant)
-        self.debug('{} impregnating: {}. {}'.format(self.id, whom.id, whom.state))
-
-class Female(RabbitModel):
-    @state
-    def fertile(self):
-        # Just wait for a Male
-        pass
-
-    @state
-    def pregnant(self):
-        self['age'] += 1
-        if self['age'] > self.life_expectancy:
-            return self.dead
-
-        self['pregnancy'] += 1
-        self.debug('Pregnancy: {}'.format(self['pregnancy']))
-        if self['pregnancy'] >= self.gestation:
-            number_of_babies = int(8+4*random())
-            self.info('Having {} babies'.format(number_of_babies))
-            for i in range(number_of_babies):
-                state = {}
-                state['gender'] = choice(list(Genders)).value
-                child = self.env.add_node(self.__class__, state)
-                self.env.add_edge(self.id, child.id)
-                self.env.add_edge(self['mate'], child.id)
-                # self.add_edge()
-                self.debug('A BABY IS COMING TO LIFE')
-                self.env['rabbits_alive'] = self.env.get('rabbits_alive', self.topology.number_of_nodes())+1
-                self.debug('Rabbits alive: {}'.format(self.env['rabbits_alive']))
-                self['offspring'] += 1
-                self.env.get_agent(self['mate'])['offspring'] += 1
-            del self['mate']
-            self['pregnancy'] = -1
-            return self.fertile
-
-    @state
-    def dead(self):
-        super().dead()
-        if 'pregnancy' in self and self['pregnancy'] > -1:
-            self.info('A mother has died carrying a baby!!')
-
-
-class RandomAccident(NetworkAgent):
-
-    level = logging.DEBUG
-
-    def step(self):
-        rabbits_total = self.topology.number_of_nodes()
-        if 'rabbits_alive' not in self.env:
-            self.env['rabbits_alive'] = 0
-        rabbits_alive = self.env.get('rabbits_alive', rabbits_total)
-        prob_death = self.env.get('prob_death', 1e-100)*math.floor(math.log10(max(1, rabbits_alive)))
-        self.debug('Killing some rabbits with prob={}!'.format(prob_death))
-        for i in self.env.network_agents:
-            if i.state['id'] == i.dead.id:
-                continue
-            r = random()
-            if r < prob_death:
-                self.debug('I killed a rabbit: {}'.format(i.id))
-                rabbits_alive = self.env['rabbits_alive'] = rabbits_alive -1
-                self.log('Rabbits alive: {}'.format(self.env['rabbits_alive']))
-                i.set_state(i.dead)
-        self.log('Rabbits alive: {}/{}'.format(rabbits_alive, rabbits_total))
-        if self.count_agents(state_id=RabbitModel.dead.id) == self.topology.number_of_nodes():
-            self.die()
--- a/examples/rabbits/rabbit_improved_sim.py
+++ b/examples/rabbits/rabbit_improved_sim.py
@@ -0,0 +1,153 @@
+from soil import FSM, state, default_state, BaseAgent, NetworkAgent, Environment, Simulation
+from soil.time import Delta
+from enum import Enum
+from collections import Counter
+import logging
+import math
+
+from rabbits_basic_sim import RabbitEnv
+
+
+class RabbitsImprovedEnv(RabbitEnv):
+    def init(self):
+        """Initialize the environment with the new versions of the agents"""
+        a1 = self.add_node(Male)
+        a2 = self.add_node(Female)
+        a1.add_edge(a2)
+        self.add_agent(RandomAccident)
+
+
+class Rabbit(FSM, NetworkAgent):
+
+    sexual_maturity = 30
+    life_expectancy = 300
+    birth = None
+
+    @property
+    def age(self):
+        if self.birth is None:
+            return None
+        return self.now - self.birth
+
+    @default_state
+    @state
+    def newborn(self):
+        self.info("I am a newborn.")
+        self.birth = self.now
+        self.offspring = 0
+        return self.youngling, Delta(self.sexual_maturity - self.age)
+
+    @state
+    def youngling(self):
+        if self.age >= self.sexual_maturity:
+            self.info(f"I am fertile! My age is {self.age}")
+            return self.fertile
+
+    @state
+    def fertile(self):
+        raise Exception("Each subclass should define its fertile state")
+
+    @state
+    def dead(self):
+        self.die()
+
+
+class Male(Rabbit):
+    max_females = 5
+    mating_prob = 0.001
+
+    @state
+    def fertile(self):
+        if self.age > self.life_expectancy:
+            return self.dead
+
+        # Males try to mate
+        for f in self.model.agents(
+            agent_class=Female, state_id=Female.fertile.id, limit=self.max_females
+        ):
+            self.debug("FOUND A FEMALE: ", repr(f), self.mating_prob)
+            if self.prob(self["mating_prob"]):
+                f.impregnate(self)
+                break  # Do not try to impregnate other females
+
+
+class Female(Rabbit):
+    gestation = 10
+    conception = None
+
+    @state
+    def fertile(self):
+        # Just wait for a Male
+        if self.age > self.life_expectancy:
+            return self.dead
+        if self.conception is not None:
+            return self.pregnant
+
+    @property
+    def pregnancy(self):
+        if self.conception is None:
+            return None
+        return self.now - self.conception
+
+    def impregnate(self, male):
+        self.info(f"impregnated by {repr(male)}")
+        self.mate = male
+        self.conception = self.now
+        self.number_of_babies = int(8 + 4 * self.random.random())
+
+    @state
+    def pregnant(self):
+        self.debug("I am pregnant")
+
+        if self.age > self.life_expectancy:
+            self.info("Dying before giving birth")
+            return self.die()
+
+        if self.pregnancy >= self.gestation:
+            self.info("Having {} babies".format(self.number_of_babies))
+            for i in range(self.number_of_babies):
+                state = {}
+                agent_class = self.random.choice([Male, Female])
+                child = self.model.add_node(agent_class=agent_class, **state)
+                child.add_edge(self)
+                if self.mate:
+                    child.add_edge(self.mate)
+                    self.mate.offspring += 1
+                else:
+                    self.debug("The father has passed away")
+
+                self.offspring += 1
+            self.mate = None
+            return self.fertile
+
+    def die(self):
+        if self.pregnancy is not None:
+            self.info("A mother has died carrying a baby!!")
+        return super().die()
+
+
+class RandomAccident(BaseAgent):
+    def step(self):
+        rabbits_alive = self.model.G.number_of_nodes()
+
+        if not rabbits_alive:
+            return self.die()
+
+        prob_death = self.model.get("prob_death", 1e-100) * math.floor(
+            math.log10(max(1, rabbits_alive))
+        )
+        self.debug("Killing some rabbits with prob={}!".format(prob_death))
+        for i in self.iter_agents(agent_class=Rabbit):
+            if i.state_id == i.dead.id:
+                continue
+            if self.prob(prob_death):
+                self.info("I killed a rabbit: {}".format(i.id))
+                rabbits_alive -= 1
+                i.die()
+        self.debug("Rabbits alive: {}".format(rabbits_alive))
+
+
+sim = Simulation(model=RabbitsImprovedEnv, max_time=100, seed="MySeed", iterations=1)
+
+if __name__ == "__main__":
+    sim.run()
--- a/examples/rabbits/rabbits.yml
+++ b/examples/rabbits/rabbits.yml
@@ -1,21 +0,0 @@
---
-load_module: rabbit_agents
-name: rabbits_example
-max_time: 1000
-interval: 1
-seed: MySeed
-agent_type: rabbit_agents.RabbitModel
-environment_agents:
-    - agent_type: rabbit_agents.RandomAccident
-environment_params:
-  prob_death: 0.001
-default_state:
-  mating_prob: 0.1
-topology:
-  nodes:
-    - id: 1
-      agent_type: rabbit_agents.Male
-    - id: 0
-      agent_type: rabbit_agents.Female
-  directed: true
-  links: []
--- a/examples/rabbits/rabbits_basic_sim.py
+++ b/examples/rabbits/rabbits_basic_sim.py
@@ -0,0 +1,161 @@
+from soil import FSM, state, default_state, BaseAgent, NetworkAgent, Environment, Simulation, report, parameters as params
+from collections import Counter
+import logging
+import math
+
+
+class RabbitEnv(Environment):
+    prob_death: params.probability = 1e-100
+
+    def init(self):
+        a1 = self.add_node(Male)
+        a2 = self.add_node(Female)
+        a1.add_edge(a2)
+        self.add_agent(RandomAccident)
+
+    @report
+    @property
+    def num_rabbits(self):
+        return self.count_agents(agent_class=Rabbit)
+
+    @report
+    @property
+    def num_males(self):
+        return self.count_agents(agent_class=Male)
+
+    @report
+    @property
+    def num_females(self):
+        return self.count_agents(agent_class=Female)
+
+
+class Rabbit(NetworkAgent, FSM):
+
+    sexual_maturity = 30
+    life_expectancy = 300
+
+    @default_state
+    @state
+    def newborn(self):
+        self.info("I am a newborn.")
+        self.age = 0
+        self.offspring = 0
+        return self.youngling
+
+    @state
+    def youngling(self):
+        self.age += 1
+        if self.age >= self.sexual_maturity:
+            self.info(f"I am fertile! My age is {self.age}")
+            return self.fertile
+
+    @state
+    def fertile(self):
+        raise Exception("Each subclass should define its fertile state")
+
+    @state
+    def dead(self):
+        self.die()
+
+
+class Male(Rabbit):
+    max_females = 5
+    mating_prob = 0.001
+
+    @state
+    def fertile(self):
+        self.age += 1
+
+        if self.age > self.life_expectancy:
+            return self.dead
+
+        # Males try to mate
+        for f in self.model.agents(
+            agent_class=Female, state_id=Female.fertile.id, limit=self.max_females
+        ):
+            self.debug("FOUND A FEMALE: ", repr(f), self.mating_prob)
+            if self.prob(self["mating_prob"]):
+                f.impregnate(self)
+                break  # Take a break
+
+
+class Female(Rabbit):
+    gestation = 10
+    pregnancy = -1
+
+    @state
+    def fertile(self):
+        # Just wait for a Male
+        self.age += 1
+        if self.age > self.life_expectancy:
+            return self.dead
+        if self.pregnancy >= 0:
+            return self.pregnant
+
+    def impregnate(self, male):
+        self.info(f"impregnated by {repr(male)}")
+        self.mate = male
+        self.pregnancy = 0
+        self.number_of_babies = int(8 + 4 * self.random.random())
+
+    @state
+    def pregnant(self):
+        self.info("I am pregnant")
+        self.age += 1
+
+        if self.age >= self.life_expectancy:
+            return self.die()
+
+        if self.pregnancy < self.gestation:
+            self.pregnancy += 1
+            return
+
+        self.info("Having {} babies".format(self.number_of_babies))
+        for i in range(self.number_of_babies):
+            state = {}
+            agent_class = self.random.choice([Male, Female])
+            child = self.model.add_node(agent_class=agent_class, **state)
+            child.add_edge(self)
+            try:
+                child.add_edge(self.mate)
+                self.model.agents[self.mate].offspring += 1
+            except ValueError:
+                self.debug("The father has passed away")
+
+            self.offspring += 1
+        self.mate = None
+        self.pregnancy = -1
+        return self.fertile
+
+    def die(self):
+        if "pregnancy" in self and self["pregnancy"] > -1:
+            self.info("A mother has died carrying a baby!!")
+        return super().die()
+
+
+class RandomAccident(BaseAgent):
+    def step(self):
+        rabbits_alive = self.model.G.number_of_nodes()
+
+        if not rabbits_alive:
+            return self.die()
+
+        prob_death = self.model.prob_death * math.floor(
+            math.log10(max(1, rabbits_alive))
+        )
+        self.debug("Killing some rabbits with prob={}!".format(prob_death))
+        for i in self.get_agents(agent_class=Rabbit):
+            if i.state_id == i.dead.id:
+                continue
+            if self.prob(prob_death):
+                self.info("I killed a rabbit: {}".format(i.id))
+                rabbits_alive -= 1
+                i.die()
+        self.debug("Rabbits alive: {}".format(rabbits_alive))
+
+
+
+sim = Simulation(model=RabbitEnv, max_time=100, seed="MySeed", iterations=1)
+
+if __name__ == "__main__":
+    sim.run()
--- a/examples/random_delays/random_delays.py
+++ b/examples/random_delays/random_delays.py
@@ -1,45 +0,0 @@
-'''
-Example of setting a 
-Example of a fully programmatic simulation, without definition files.
-'''
-from soil import Simulation, agents
-from soil.time import Delta
-from random import expovariate
-import logging
-
-
-
-class MyAgent(agents.FSM):
-    '''
-    An agent that first does a ping
-    '''
-
-    defaults = {'pong_counts': 2}
-
-    @agents.default_state
-    @agents.state
-    def ping(self):
-        self.info('Ping')
-        return self.pong, Delta(expovariate(1/16))
-
-    @agents.state
-    def pong(self):
-        self.info('Pong')
-        self.pong_counts -= 1
-        self.info(str(self.pong_counts))
-        if self.pong_counts < 1:
-            return self.die()
-        return None, Delta(expovariate(1/16))
-
-
-s = Simulation(name='Programmatic',
-               network_agents=[{'agent_type': MyAgent, 'id': 0}],
-               topology={'nodes': [{'id': 0}], 'links': []},
-               num_trials=1,
-               max_time=100,
-               agent_type=MyAgent,
-               dry_run=True)
-
-
-logging.basicConfig(level=logging.INFO)
-envs = s.run()
--- a/examples/random_delays/random_delays_sim.py
+++ b/examples/random_delays/random_delays_sim.py
@@ -0,0 +1,47 @@
+"""
+Example of setting a 
+Example of a fully programmatic simulation, without definition files.
+"""
+from soil import Simulation, agents, Environment
+from soil.time import Delta
+
+
+class MyAgent(agents.FSM):
+    """
+    An agent that first does a ping
+    """
+
+    defaults = {"pong_counts": 2}
+
+    @agents.default_state
+    @agents.state
+    def ping(self):
+        self.info("Ping")
+        return self.pong, Delta(self.random.expovariate(1 / 16))
+
+    @agents.state
+    def pong(self):
+        self.info("Pong")
+        self.pong_counts -= 1
+        self.info(str(self.pong_counts))
+        if self.pong_counts < 1:
+            return self.die()
+        return None, Delta(self.random.expovariate(1 / 16))
+
+
+class RandomEnv(Environment):
+
+    def init(self):
+        self.add_agent(agent_class=MyAgent)
+
+
+s = Simulation(
+    name="Programmatic",
+    model=RandomEnv,
+    iterations=1,
+    max_time=100,
+    dump=False,
+)
+
+
+envs = s.run()
--- a/examples/template.yml
+++ b/examples/template.yml
@@ -1,30 +0,0 @@
---
-sampler:
-  method: "SALib.sample.morris.sample"
-  N: 10
-template:
-  group: simple
-  num_trials: 1
-  interval: 1
-  max_time: 2
-  seed: "CompleteSeed!"
-  dump: false
-  network_params:
-    generator: complete_graph
-    n: 10
-  network_agents:
-    - agent_type: CounterModel
-      weight: "{{ x1 }}"
-      state:
-        state_id: 0
-    - agent_type: AggregatedCounter
-      weight: "{{ 1 - x1 }}"
-  environment_params:
-    name: "{{ x3 }}"
-  skip_test: true
-vars:
-  bounds:
-    x1: [0, 1]
-    x2: [1, 2]
-  fixed:
-    x3: ["a", "b", "c"]
--- a/examples/terrorism/TerroristNetworkModel.py
+++ b/examples/terrorism/TerroristNetworkModel.py
@@ -1,208 +0,0 @@
-import random
-import networkx as nx
-from soil.agents import Geo, NetworkAgent, FSM, state, default_state
-from soil import Environment
-
-
-class TerroristSpreadModel(FSM, Geo):
-    """
-    Settings:
-        information_spread_intensity
-
-        terrorist_additional_influence
-
-        min_vulnerability (optional else zero)
-
-        max_vulnerability
-
-        prob_interaction
-    """
-
-    def __init__(self, model=None, unique_id=0, state=()):
-        super().__init__(model=model, unique_id=unique_id, state=state)
-
-        self.information_spread_intensity = model.environment_params['information_spread_intensity']
-        self.terrorist_additional_influence = model.environment_params['terrorist_additional_influence']
-        self.prob_interaction = model.environment_params['prob_interaction']
-
-        if self['id'] == self.civilian.id:       # Civilian
-            self.mean_belief = random.uniform(0.00, 0.5)
-        elif self['id'] == self.terrorist.id:     # Terrorist
-            self.mean_belief = random.uniform(0.8, 1.00)
-        elif self['id'] == self.leader.id:     # Leader
-            self.mean_belief = 1.00
-        else:
-            raise Exception('Invalid state id: {}'.format(self['id']))
-
-        if 'min_vulnerability' in model.environment_params:
-            self.vulnerability = random.uniform( model.environment_params['min_vulnerability'], model.environment_params['max_vulnerability'] )
-        else :
-            self.vulnerability = random.uniform( 0, model.environment_params['max_vulnerability'] )
-
-
-    @state
-    def civilian(self):
-        neighbours = list(self.get_neighboring_agents(agent_type=TerroristSpreadModel))
-        if len(neighbours) > 0:
-            # Only interact with some of the neighbors
-            interactions = list(n for n in neighbours if random.random() <= self.prob_interaction)
-            influence = sum( self.degree(i) for i in interactions )
-            mean_belief = sum( i.mean_belief * self.degree(i) / influence for i in interactions )
-            mean_belief = mean_belief * self.information_spread_intensity + self.mean_belief * ( 1 - self.information_spread_intensity )
-            self.mean_belief = mean_belief * self.vulnerability + self.mean_belief * ( 1 - self.vulnerability )
-        
-        if self.mean_belief >= 0.8:
-            return self.terrorist
-
-    @state
-    def leader(self):
-        self.mean_belief = self.mean_belief ** ( 1 - self.terrorist_additional_influence )
-        for neighbour in self.get_neighboring_agents(state_id=[self.terrorist.id, self.leader.id]):
-            if self.betweenness(neighbour) > self.betweenness(self):
-                return self.terrorist
-
-    @state
-    def terrorist(self):
-        neighbours = self.get_agents(state_id=[self.terrorist.id, self.leader.id],
-                                     agent_type=TerroristSpreadModel,
-                                     limit_neighbors=True)
-        if len(neighbours) > 0:
-            influence = sum( self.degree(n) for n in neighbours )
-            mean_belief = sum( n.mean_belief * self.degree(n) / influence for n in neighbours )
-            mean_belief = mean_belief * self.vulnerability + self.mean_belief * ( 1 - self.vulnerability )
-            self.mean_belief = self.mean_belief ** ( 1 - self.terrorist_additional_influence )
-
-        # Check if there are any leaders in the group
-        leaders = list(filter(lambda x: x.state.id == self.leader.id, neighbours))
-        if not leaders:
-            # Check if this is the potential leader
-            # Stop once it's found. Otherwise, set self as leader
-            for neighbour in neighbours:
-                if self.betweenness(self) < self.betweenness(neighbour):
-                    return
-            return self.leader
-
-
-class TrainingAreaModel(FSM, Geo):
-    """
-    Settings:
-        training_influence
-
-        min_vulnerability
-
-    Requires TerroristSpreadModel.
-    """
-
-    def __init__(self, model=None, unique_id=0, state=()):
-        super().__init__(model=model, unique_id=unique_id, state=state)
-        self.training_influence = model.environment_params['training_influence']
-        if 'min_vulnerability' in model.environment_params:
-            self.min_vulnerability = model.environment_params['min_vulnerability']
-        else: self.min_vulnerability = 0
-
-    @default_state
-    @state
-    def terrorist(self):
-        for neighbour in self.get_neighboring_agents(agent_type=TerroristSpreadModel):
-            if neighbour.vulnerability > self.min_vulnerability:
-                neighbour.vulnerability = neighbour.vulnerability ** ( 1 - self.training_influence )        
-
-
-class HavenModel(FSM, Geo):
-    """
-    Settings:
-        haven_influence
-
-        min_vulnerability
-
-        max_vulnerability
-
-    Requires TerroristSpreadModel.
-    """
-
-    def __init__(self, model=None, unique_id=0, state=()):
-        super().__init__(model=model, unique_id=unique_id, state=state)
-        self.haven_influence = model.environment_params['haven_influence']
-        if 'min_vulnerability' in model.environment_params:
-            self.min_vulnerability = model.environment_params['min_vulnerability']
-        else: self.min_vulnerability = 0
-        self.max_vulnerability = model.environment_params['max_vulnerability']
-
-    def get_occupants(self, **kwargs):
-        return self.get_neighboring_agents(agent_type=TerroristSpreadModel, **kwargs)
-
-    @state
-    def civilian(self):
-        civilians = self.get_occupants(state_id=self.civilian.id)
-        if not civilians:
-            return self.terrorist
-
-        for neighbour in self.get_occupants():
-            if neighbour.vulnerability > self.min_vulnerability:
-                neighbour.vulnerability = neighbour.vulnerability * ( 1 - self.haven_influence )
-        return self.civilian
-
-    @state
-    def terrorist(self):
-        for neighbour in self.get_occupants():
-            if neighbour.vulnerability < self.max_vulnerability:
-                neighbour.vulnerability = neighbour.vulnerability ** ( 1 - self.haven_influence )
-        return self.terrorist
-
-
-class TerroristNetworkModel(TerroristSpreadModel):
-    """
-    Settings:
-        sphere_influence
-
-        vision_range
-
-        weight_social_distance
-
-        weight_link_distance
-    """
-
-    def __init__(self, model=None, unique_id=0, state=()):
-        super().__init__(model=model, unique_id=unique_id, state=state)
-
-        self.vision_range = model.environment_params['vision_range']
-        self.sphere_influence = model.environment_params['sphere_influence']
-        self.weight_social_distance = model.environment_params['weight_social_distance']
-        self.weight_link_distance = model.environment_params['weight_link_distance']
-
-    @state
-    def terrorist(self):
-        self.update_relationships()
-        return super().terrorist()
-
-    @state
-    def leader(self):
-        self.update_relationships()
-        return super().leader()
-
-    def update_relationships(self):
-        if self.count_neighboring_agents(state_id=self.civilian.id) == 0:
-            close_ups = set(self.geo_search(radius=self.vision_range, agent_type=TerroristNetworkModel))
-            step_neighbours = set(self.ego_search(self.sphere_influence, agent_type=TerroristNetworkModel, center=False))
-            neighbours = set(agent.id for agent in self.get_neighboring_agents(agent_type=TerroristNetworkModel))
-            search = (close_ups | step_neighbours) - neighbours
-            for agent in self.get_agents(search):
-                social_distance = 1 / self.shortest_path_length(agent.id)
-                spatial_proximity = ( 1 - self.get_distance(agent.id) )
-                prob_new_interaction = self.weight_social_distance * social_distance + self.weight_link_distance * spatial_proximity
-                if agent['id'] == agent.civilian.id and random.random() < prob_new_interaction:
-                    self.add_edge(agent)
-                    break
-
-    def get_distance(self, target):
-        source_x, source_y = nx.get_node_attributes(self.topology, 'pos')[self.id]
-        target_x, target_y = nx.get_node_attributes(self.topology, 'pos')[target]
-        dx = abs( source_x - target_x )
-        dy = abs( source_y - target_y )
-        return ( dx ** 2 + dy ** 2 ) ** ( 1 / 2 )
-
-    def shortest_path_length(self, target):
-        try:
-            return nx.shortest_path_length(self.topology, self.id, target)
-        except nx.NetworkXNoPath:
-            return float('inf')
--- a/examples/terrorism/TerroristNetworkModel.yml
+++ b/examples/terrorism/TerroristNetworkModel.yml
@@ -1,63 +0,0 @@
-name: TerroristNetworkModel_sim
-load_module: TerroristNetworkModel
-max_time: 150 
-num_trials: 1
-network_params:
-  generator: random_geometric_graph
-  radius: 0.2
-  # generator: geographical_threshold_graph
-  # theta: 20
-  n: 100
-network_agents:
-  - agent_type: TerroristNetworkModel
-    weight: 0.8
-    state:
-      id: civilian  # Civilians
-  - agent_type: TerroristNetworkModel
-    weight: 0.1
-    state:
-      id: leader    # Leaders
-  - agent_type: TrainingAreaModel
-    weight: 0.05
-    state:
-      id: terrorist # Terrorism
-  - agent_type: HavenModel
-    weight: 0.05
-    state:
-      id: civilian  # Civilian
-
-environment_params:
-  # TerroristSpreadModel
-  information_spread_intensity: 0.7
-  terrorist_additional_influence: 0.035
-  max_vulnerability: 0.7
-  prob_interaction: 0.5
-
-  # TrainingAreaModel and HavenModel
-  training_influence: 0.20
-  haven_influence: 0.20
-
-  # TerroristNetworkModel
-  vision_range: 0.30
-  sphere_influence: 2
-  weight_social_distance: 0.035
-  weight_link_distance: 0.035
-
-visualization_params:
-  # Icons downloaded from https://www.iconfinder.com/
-  shape_property: agent
-  shapes:
-    TrainingAreaModel: target
-    HavenModel: home
-    TerroristNetworkModel: person
-  colors:
-    - attr_id: civilian
-      color: '#40de40'
-    - attr_id: terrorist
-      color: red
-    - attr_id: leader
-      color: '#c16a6a'
-  background_image: 'map_4800x2860.jpg'
-  background_opacity: '0.9'
-  background_filter_color: 'blue'
-skip_test: true  # This simulation takes too long for automated tests.
--- a/examples/terrorism/TerroristNetworkModel_sim.py
+++ b/examples/terrorism/TerroristNetworkModel_sim.py
@@ -0,0 +1,341 @@
+import networkx as nx
+from soil.agents import Geo, NetworkAgent, FSM, custom, state, default_state
+from soil import Environment, Simulation
+from soil.parameters import *
+from soil.utils import int_seed
+
+
+class TerroristEnvironment(Environment):
+    n: Integer = 100
+    radius: Float = 0.2
+
+    information_spread_intensity: probability = 0.7
+    terrorist_additional_influence: probability = 0.03
+    terrorist_additional_influence: probability = 0.035
+    max_vulnerability: probability = 0.7
+    prob_interaction: probability = 0.5
+
+    # TrainingAreaModel and HavenModel
+    training_influence: probability = 0.20
+    haven_influence: probability = 0.20
+
+    # TerroristNetworkModel
+    vision_range: Float = 0.30
+    sphere_influence: Integer = 2
+    weight_social_distance: Float = 0.035
+    weight_link_distance: Float = 0.035
+
+    ratio_civil: probability = 0.8
+    ratio_leader: probability = 0.1
+    ratio_training: probability = 0.05
+    ratio_haven: probability = 0.05
+
+    def init(self):
+        self.create_network(generator=self.generator, n=self.n, radius=self.radius)
+        self.populate_network([
+            TerroristNetworkModel.w(state_id='civilian'),
+            TerroristNetworkModel.w(state_id='leader'),
+            TrainingAreaModel,
+            HavenModel
+        ], [self.ratio_civil, self.ratio_leader, self.ratio_training, self.ratio_haven])
+
+    def generator(self, *args, **kwargs):
+        return nx.random_geometric_graph(*args, **kwargs, seed=int_seed(self._seed))
+
+class TerroristSpreadModel(FSM, Geo):
+    """
+    Settings:
+        information_spread_intensity
+
+        terrorist_additional_influence
+
+        min_vulnerability (optional else zero)
+
+        max_vulnerability
+    """
+
+    information_spread_intensity = 0.1
+    terrorist_additional_influence = 0.1
+    min_vulnerability = 0
+    max_vulnerability = 1
+
+    def init(self):
+        if self.state_id == self.civilian.id:  # Civilian
+            self.mean_belief = self.model.random.uniform(0.00, 0.5)
+        elif self.state_id == self.terrorist.id:  # Terrorist
+            self.mean_belief = self.random.uniform(0.8, 1.00)
+        elif self.state_id == self.leader.id:  # Leader
+            self.mean_belief = 1.00
+        else:
+            raise Exception("Invalid state id: {}".format(self["id"]))
+
+        self.vulnerability = self.random.uniform(
+            self.get("min_vulnerability", 0), self.get("max_vulnerability", 1)
+        )
+
+    @default_state
+    @state
+    def civilian(self):
+        neighbours = list(self.get_neighbors(agent_class=TerroristSpreadModel))
+        if len(neighbours) > 0:
+            # Only interact with some of the neighbors
+            interactions = list(
+                n for n in neighbours if self.random.random() <= self.model.prob_interaction
+            )
+            influence = sum(self.degree(i) for i in interactions)
+            mean_belief = sum(
+                i.mean_belief * self.degree(i) / influence for i in interactions
+            )
+            mean_belief = (
+                mean_belief * self.information_spread_intensity
+                + self.mean_belief * (1 - self.information_spread_intensity)
+            )
+            self.mean_belief = mean_belief * self.vulnerability + self.mean_belief * (
+                1 - self.vulnerability
+            )
+
+        if self.mean_belief >= 0.8:
+            return self.terrorist
+
+    @state
+    def leader(self):
+        self.mean_belief = self.mean_belief ** (1 - self.terrorist_additional_influence)
+        for neighbour in self.get_neighbors(
+            state_id=[self.terrorist.id, self.leader.id]
+        ):
+            if self.betweenness(neighbour) > self.betweenness(self):
+                return self.terrorist
+
+    @state
+    def terrorist(self):
+        neighbours = self.get_agents(
+            state_id=[self.terrorist.id, self.leader.id],
+            agent_class=TerroristSpreadModel,
+            limit_neighbors=True,
+        )
+        if len(neighbours) > 0:
+            influence = sum(self.degree(n) for n in neighbours)
+            mean_belief = sum(
+                n.mean_belief * self.degree(n) / influence for n in neighbours
+            )
+            mean_belief = mean_belief * self.vulnerability + self.mean_belief * (
+                1 - self.vulnerability
+            )
+            self.mean_belief = self.mean_belief ** (
+                1 - self.terrorist_additional_influence
+            )
+
+        # Check if there are any leaders in the group
+        leaders = list(filter(lambda x: x.state_id == self.leader.id, neighbours))
+        if not leaders:
+            # Check if this is the potential leader
+            # Stop once it's found. Otherwise, set self as leader
+            for neighbour in neighbours:
+                if self.betweenness(self) < self.betweenness(neighbour):
+                    return
+            return self.leader
+
+    def ego_search(self, steps=1, center=False, agent=None, **kwargs):
+        """Get a list of nodes in the ego network of *node* of radius *steps*"""
+        node = agent.node_id if agent else self.node_id
+        G = self.subgraph(**kwargs)
+        return nx.ego_graph(G, node, center=center, radius=steps).nodes()
+
+    def degree(self, agent, force=False):
+        if (
+            force
+            or (not hasattr(self.model, "_degree"))
+            or getattr(self.model, "_last_step", 0) < self.now
+        ):
+            self.model._degree = nx.degree_centrality(self.G)
+            self.model._last_step = self.now
+        return self.model._degree[agent.node_id]
+
+    def betweenness(self, agent, force=False):
+        if (
+            force
+            or (not hasattr(self.model, "_betweenness"))
+            or getattr(self.model, "_last_step", 0) < self.now
+        ):
+            self.model._betweenness = nx.betweenness_centrality(self.G)
+            self.model._last_step = self.now
+        return self.model._betweenness[agent.node_id]
+
+
+class TrainingAreaModel(FSM, Geo):
+    """
+    Settings:
+        training_influence
+
+        min_vulnerability
+
+    Requires TerroristSpreadModel.
+    """
+
+    training_influence = 0.1
+    min_vulnerability = 0
+
+    def init(self):
+        self.mean_believe = 1
+        self.vulnerability = 0
+
+    @default_state
+    @state
+    def terrorist(self):
+        for neighbour in self.get_neighbors(agent_class=TerroristSpreadModel):
+            if neighbour.vulnerability > self.min_vulnerability:
+                neighbour.vulnerability = neighbour.vulnerability ** (
+                    1 - self.training_influence
+                )
+
+
+class HavenModel(FSM, Geo):
+    """
+    Settings:
+        haven_influence
+
+        min_vulnerability
+
+        max_vulnerability
+
+    Requires TerroristSpreadModel.
+    """
+
+    min_vulnerability = 0
+    haven_influence = 0.1
+    max_vulnerability = 0.5
+
+    def init(self):
+        self.mean_believe = 0
+        self.vulnerability = 0
+
+    def get_occupants(self, **kwargs):
+        return self.get_neighbors(agent_class=TerroristSpreadModel,
+                                  **kwargs)
+
+    @default_state
+    @state
+    def civilian(self):
+        civilians = self.get_occupants(state_id=self.civilian.id)
+        if not civilians:
+            return self.terrorist
+
+        for neighbour in self.get_occupants():
+            if neighbour.vulnerability > self.min_vulnerability:
+                neighbour.vulnerability = neighbour.vulnerability * (
+                    1 - self.haven_influence
+                )
+        return self.civilian
+
+    @state
+    def terrorist(self):
+        for neighbour in self.get_occupants():
+            if neighbour.vulnerability < self.max_vulnerability:
+                neighbour.vulnerability = neighbour.vulnerability ** (
+                    1 - self.haven_influence
+                )
+        return self.terrorist
+
+
+class TerroristNetworkModel(TerroristSpreadModel):
+    """
+    Settings:
+        sphere_influence
+
+        vision_range
+
+        weight_social_distance
+
+        weight_link_distance
+    """
+
+    sphere_influence: float = 1
+    vision_range: float = 1
+    weight_social_distance: float = 0.5
+    weight_link_distance: float = 0.2
+
+    @state
+    def terrorist(self):
+        self.update_relationships()
+        return super().terrorist()
+
+    @state
+    def leader(self):
+        self.update_relationships()
+        return super().leader()
+
+    def update_relationships(self):
+        if self.count_neighbors(state_id=self.civilian.id) == 0:
+            close_ups = set(
+                self.geo_search(
+                    radius=self.vision_range, agent_class=TerroristNetworkModel
+                )
+            )
+            step_neighbours = set(
+                self.ego_search(
+                    self.sphere_influence,
+                    agent_class=TerroristNetworkModel,
+                    center=False,
+                )
+            )
+            neighbours = set(
+                agent.unique_id
+                for agent in self.get_neighbors(agent_class=TerroristNetworkModel)
+            )
+            search = (close_ups | step_neighbours) - neighbours
+            for agent in self.get_agents(search):
+                social_distance = 1 / self.shortest_path_length(agent.unique_id)
+                spatial_proximity = 1 - self.get_distance(agent.unique_id)
+                prob_new_interaction = (
+                    self.weight_social_distance * social_distance
+                    + self.weight_link_distance * spatial_proximity
+                )
+                if (
+                    agent.state_id == "civilian"
+                    and self.random.random() < prob_new_interaction
+                ):
+                    self.add_edge(agent)
+                    break
+
+    def get_distance(self, target):
+        source_x, source_y = nx.get_node_attributes(self.G, "pos")[self.unique_id]
+        target_x, target_y = nx.get_node_attributes(self.G, "pos")[target]
+        dx = abs(source_x - target_x)
+        dy = abs(source_y - target_y)
+        return (dx**2 + dy**2) ** (1 / 2)
+
+    def shortest_path_length(self, target):
+        try:
+            return nx.shortest_path_length(self.G, self.unique_id, target)
+        except nx.NetworkXNoPath:
+            return float("inf")
+
+
+sim = Simulation(
+    model=TerroristEnvironment,
+    iterations=1,
+    name="TerroristNetworkModel_sim",
+    max_steps=150,
+    seed="default2",
+    skip_test=False,
+    dump=False,
+)
+
+# TODO: integrate visualization
+# visualization_params:
+#   # Icons downloaded from https://www.iconfinder.com/
+#   shape_property: agent
+#   shapes:
+#     TrainingAreaModel: target
+#     HavenModel: home
+#     TerroristNetworkModel: person
+#   colors:
+#     - attr_id: civilian
+#       color: '#40de40'
+#     - attr_id: terrorist
+#       color: red
+#     - attr_id: leader
+#       color: '#c16a6a'
+#   background_image: 'map_4800x2860.jpg'
+#   background_opacity: '0.9'
+#   background_filter_color: 'blue'
--- a/examples/torvalds.yml
+++ b/examples/torvalds.yml
@@ -1,14 +0,0 @@
---
-name: torvalds_example
-max_time: 10
-interval: 2
-agent_type: CounterModel
-default_state:
-  skill_level: 'beginner'
-network_params:
-  path: 'torvalds.edgelist'
-states:
-  Torvalds:
-    skill_level: 'God'
-  balkian:
-    skill_level: 'developer'
--- a/examples/torvalds_sim.py
+++ b/examples/torvalds_sim.py
@@ -0,0 +1,25 @@
+from soil import Environment, Simulation, CounterModel, report
+
+
+# Get directory path for current file
+import os, sys, inspect
+currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
+
+class TorvaldsEnv(Environment):
+
+  def init(self):
+    self.create_network(path=os.path.join(currentdir, 'torvalds.edgelist'))
+    self.populate_network(CounterModel, skill_level='beginner')
+    self.agent(node_id="Torvalds").skill_level = 'God'
+    self.agent(node_id="balkian").skill_level = 'developer'
+    self.add_agent_reporter("times")
+
+  @report
+  def god_developers(self):
+    return self.count_agents(skill_level='God')
+  
+
+sim = Simulation(name='torvalds_example',
+                 max_steps=10,
+                 interval=2,
+                 model=TorvaldsEnv)
--- a/examples/tutorial/soil_tutorial.html
+++ b/examples/tutorial/soil_tutorial.html
@@ -12330,11 +12330,11 @@ Notice how node 0 is the only one with a TV.</p>
 <span class="n">sim</span> <span class="o">=</span> <span class="n">soil</span><span class="o">.</span><span class="n">Simulation</span><span class="p">(</span><span class="n">topology</span><span class="o">=</span><span class="n">G</span><span class="p">,</span>
                                     <span class="n">num_trials</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span>
                                     <span class="n">max_time</span><span class="o">=</span><span class="n">MAX_TIME</span><span class="p">,</span>
-                                     <span class="n">environment_agents</span><span class="o">=</span><span class="p">[{</span><span class="s1">&#39;agent_type&#39;</span><span class="p">:</span> <span class="n">NewsEnvironmentAgent</span><span class="p">,</span>
+                                     <span class="n">environment_agents</span><span class="o">=</span><span class="p">[{</span><span class="s1">&#39;agent_class&#39;</span><span class="p">:</span> <span class="n">NewsEnvironmentAgent</span><span class="p">,</span>
                                                         <span class="s1">&#39;state&#39;</span><span class="p">:</span> <span class="p">{</span>
                                                             <span class="s1">&#39;event_time&#39;</span><span class="p">:</span> <span class="n">EVENT_TIME</span>
                                                         <span class="p">}}],</span>
-                                     <span class="n">network_agents</span><span class="o">=</span><span class="p">[{</span><span class="s1">&#39;agent_type&#39;</span><span class="p">:</span> <span class="n">NewsSpread</span><span class="p">,</span>
+                                     <span class="n">network_agents</span><span class="o">=</span><span class="p">[{</span><span class="s1">&#39;agent_class&#39;</span><span class="p">:</span> <span class="n">NewsSpread</span><span class="p">,</span>
                                                      <span class="s1">&#39;weight&#39;</span><span class="p">:</span> <span class="mi">1</span><span class="p">}],</span>
                                     <span class="n">states</span><span class="o">=</span><span class="p">{</span><span class="mi">0</span><span class="p">:</span> <span class="p">{</span><span class="s1">&#39;has_tv&#39;</span><span class="p">:</span> <span class="kc">True</span><span class="p">}},</span>
                                     <span class="n">default_state</span><span class="o">=</span><span class="p">{</span><span class="s1">&#39;has_tv&#39;</span><span class="p">:</span> <span class="kc">False</span><span class="p">},</span>
@@ -12468,14 +12468,14 @@ For this demo, we will use a python dictionary:</p>
    <span class="p">},</span>
    <span class="s1">&#39;network_agents&#39;</span><span class="p">:</span> <span class="p">[</span>
        <span class="p">{</span>
-            <span class="s1">&#39;agent_type&#39;</span><span class="p">:</span> <span class="n">NewsSpread</span><span class="p">,</span>
+            <span class="s1">&#39;agent_class&#39;</span><span class="p">:</span> <span class="n">NewsSpread</span><span class="p">,</span>
            <span class="s1">&#39;weight&#39;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>
            <span class="s1">&#39;state&#39;</span><span class="p">:</span> <span class="p">{</span>
                <span class="s1">&#39;has_tv&#39;</span><span class="p">:</span> <span class="kc">False</span>
            <span class="p">}</span>
        <span class="p">},</span>
        <span class="p">{</span>
-            <span class="s1">&#39;agent_type&#39;</span><span class="p">:</span> <span class="n">NewsSpread</span><span class="p">,</span>
+            <span class="s1">&#39;agent_class&#39;</span><span class="p">:</span> <span class="n">NewsSpread</span><span class="p">,</span>
            <span class="s1">&#39;weight&#39;</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span>
            <span class="s1">&#39;state&#39;</span><span class="p">:</span> <span class="p">{</span>
                <span class="s1">&#39;has_tv&#39;</span><span class="p">:</span> <span class="kc">True</span>
@@ -12483,7 +12483,7 @@ For this demo, we will use a python dictionary:</p>
        <span class="p">}</span>
    <span class="p">],</span>
    <span class="s1">&#39;environment_agents&#39;</span><span class="p">:[</span>
-        <span class="p">{</span><span class="s1">&#39;agent_type&#39;</span><span class="p">:</span> <span class="n">NewsEnvironmentAgent</span><span class="p">,</span>
+        <span class="p">{</span><span class="s1">&#39;agent_class&#39;</span><span class="p">:</span> <span class="n">NewsEnvironmentAgent</span><span class="p">,</span>
         <span class="s1">&#39;state&#39;</span><span class="p">:</span> <span class="p">{</span>
             <span class="s1">&#39;event_time&#39;</span><span class="p">:</span> <span class="mi">10</span>
         <span class="p">}</span>
--- a/examples/tutorial/soil_tutorial.ipynb
+++ b/examples/tutorial/soil_tutorial.ipynb