Merge branch 'mesa'

First iteration to achieve MESA compatibility.
As a side effect, we have removed `simpy`.

For a full list of changes, see `CHANGELOG.md`.

.gitignore

@@ -8,3 +8,4 @@ soil_output
 docs/_build*
 build/*
 dist/*
+prof
\ No newline at end of file

CHANGELOG.md

@@ -3,6 +3,21 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.20.0]
+### Added
+* Integration with MESA
+* `not_agent_ids` parameter to get sql in history
+### Changed
+* `soil.Environment` now also inherits from `mesa.Model`
+* `soil.Agent` now also inherits from `mesa.Agent`
+* `soil.time` to replace `simpy` events, delays, duration, etc.
+* `agent.id` is not `agent.unique_id` to be compatible with `mesa`. A property `BaseAgent.id` has been added for compatibility.
+* `agent.environment` is now `agent.model`, for the same reason as above. The parameter name in `BaseAgent.__init__` has also been renamed.
+### Removed
+* `simpy` dependency and compatibility. Each agent used to be a simpy generator, but that made debugging and error handling more complex. That has been replaced by a scheduler within the `soil.Environment` class, similar to how `mesa` does it.
+* `soil.history` is now a separate package named `tsih`. The keys namedtuple uses `dict_id` instead of `agent_id`.
+### Added
+* An option to choose whether a database should be used for history 
 ## [0.15.2]
 ### Fixed
 * Pass the right known_modules and parameters to stats discovery in simulation

README.md

@@ -5,6 +5,9 @@ Learn how to run your own simulations with our [documentation](http://soilsim.re
 
 Follow our [tutorial](examples/tutorial/soil_tutorial.ipynb) to develop your own agent models.
 
+## Citation 
+
+
 If you use Soil in your research, don't forget to cite this paper:
 
 ```bibtex
@@ -28,7 +31,24 @@ If you use Soil in your research, don't forget to cite this paper:
 
 ```
 
-@Copyright GSI - Universidad Politécnica de Madrid 2017
+## Mesa compatibility
 
-[![SOIL](logo_gsi.png)](https://www.gsi.upm.es)
+Soil is in the process of becoming fully compatible with MESA.
+As of this writing, 
+
+This is a non-exhaustive list of tasks to achieve compatibility:
 
+* Environments.agents and mesa.Agent.agents are not the same. env is a property, and it only takes into account network and environment agents. Might rename environment_agents to other_agents or sth like that
+- [ ] Integrate `soil.Simulation` with mesa's runners:
+  - [ ] `soil.Simulation` could mimic/become a `mesa.batchrunner`
+- [ ] Integrate `soil.Environment` with `mesa.Model`:
+  - [x] `Soil.Environment` inherits from `mesa.Model`
+  - [x] `Soil.Environment` includes a Mesa-like Scheduler (see the `soil.time` module.
+- [ ] Integrate `soil.Agent` with `mesa.Agent`:
+  - [x] Rename agent.id to unique_id?
+  - [x] mesa agents can be used in soil simulations (see `examples/mesa`)
+- [ ] Document the new APIs and usage
+
+@Copyright GSI - Universidad Politécnica de Madrid 2017-2021
+
+[![SOIL](logo_gsi.png)](https://www.gsi.upm.es)

docs/soil_tutorial.rst

@@ -47,12 +47,6 @@ There are three main elements in a soil simulation:
 -  The environment. It assigns agents to nodes in the network, and
    stores the environment parameters (shared state for all agents).
 
-Soil is based on ``simpy``, which is an event-based network simulation
-library. Soil provides several abstractions over events to make
-developing agents easier. This means you can use events (timeouts,
-delays) in soil, but for the most part we will assume your models will
-be step-based.
-
 Modeling behaviour
 ------------------
 

examples/complete.yml

@@ -13,7 +13,7 @@ network_agents:
   - agent_type: CounterModel
     weight: 1
     state:
-      id: 0
+      state_id: 0
   - agent_type: AggregatedCounter
     weight: 0.2
 environment_agents: []

examples/custom_generator/custom_generator.yml

@@ -13,4 +13,4 @@ network_agents:
   - agent_type: CounterModel
     weight: 1
     state:
-      id: 0
+      state_id: 0

examples/mesa/mesa.yml

+---
+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

examples/mesa/server.py

+from mesa.visualization.ModularVisualization import ModularServer
+from soil.visualization import UserSettableParameter
+from mesa.visualization.modules import ChartModule, NetworkModule, CanvasGrid
+from social_wealth import MoneyEnv, graph_generator, SocialMoneyAgent
+
+
+class MyNetwork(NetworkModule):
+    def render(self, model):
+        return self.portrayal_method(model)
+
+
+def network_portrayal(env):
+    # The model ensures there is 0 or 1 agent per node
+
+    portrayal = dict()
+    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}",
+        }
+        for (agent_id) in env.G.nodes
+    ]
+
+    portrayal["edges"] = [
+        {"id": edge_id, "source": source, "target": target, "color": "#000000"}
+        for edge_id, (source, target) in enumerate(env.G.edges)
+    ]
+
+
+    return portrayal
+
+
+def gridPortrayal(agent):
+    """
+    This function is registered with the visualization server to be called
+    each tick to indicate how to draw the agent in its current state.
+    :param agent:  the agent in the simulation
+    :return: the portrayal dictionary
+    """
+    color = max(10, min(agent.wealth*10, 100))
+    return {
+        "Shape": "rect",
+        "w": 1,
+        "h": 1,
+        "Filled": "true",
+        "Layer": 0,
+        "Label": agent.unique_id,
+        "Text": agent.unique_id,
+        "x": agent.pos[0],
+        "y": agent.pos[1],
+        "Color": f"rgba(31, 10, 255, 0.{color})"
+    }
+
+
+grid = MyNetwork(network_portrayal, 500, 500, library="sigma")
+chart = ChartModule(
+    [{"Label": "Gini", "Color": "Black"}], data_collector_name="datacollector"
+)
+
+model_params = {
+    "N": UserSettableParameter(
+        "slider",
+        "N",
+        5,
+        1,
+        10,
+        1,
+        description="Choose how many agents to include in the model",
+    ),
+    "network_agents": [{"agent_type": SocialMoneyAgent}],
+    "height": UserSettableParameter(
+        "slider",
+        "height",
+        5,
+        5,
+        10,
+        1,
+        description="Grid height",
+        ),
+    "width": UserSettableParameter(
+        "slider",
+        "width",
+        5,
+        5,
+        10,
+        1,
+        description="Grid width",
+        ),
+    "network_params": {
+        'generator': graph_generator
+    },
+}
+
+canvas_element = CanvasGrid(gridPortrayal, model_params["width"].value, model_params["height"].value, 500, 500)
+
+
+server = ModularServer(
+    MoneyEnv, [grid, chart, canvas_element], "Money Model", model_params
+)
+server.port = 8521
+
+server.launch(open_browser=False)

examples/mesa/social_wealth.py

+'''
+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
+
+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)
+
+class MoneyAgent(MesaAgent):
+    """
+    A MESA agent with fixed initial wealth.
+    It will only share wealth with neighbors based on grid proximity
+    """
+
+    def __init__(self, unique_id, model):
+        super().__init__(unique_id=unique_id, model=model)
+        self.wealth = 1
+
+    def move(self):
+        possible_steps = self.model.grid.get_neighborhood(
+            self.pos,
+            moore=True,
+            include_center=False)
+        new_position = self.random.choice(possible_steps)
+        self.model.grid.move_agent(self, new_position)
+
+    def give_money(self):
+        cellmates = self.model.grid.get_cell_list_contents([self.pos])
+        if len(cellmates) > 1:
+            other = self.random.choice(cellmates)
+            other.wealth += 1
+            self.wealth -= 1
+
+    def step(self):
+        self.info("Crying wolf", self.pos)
+        self.move()
+        if self.wealth > 0:
+            self.give_money()
+
+
+class SocialMoneyAgent(NetworkAgent, MoneyAgent):
+    wealth = 1
+
+    def give_money(self):
+        cellmates = set(self.model.grid.get_cell_list_contents([self.pos]))
+        friends = set(self.get_neighboring_agents())
+        self.info("Trying to give money")
+        self.debug("Cellmates: ", cellmates)
+        self.debug("Friends: ", friends)
+
+        nearby_friends = list(cellmates & friends)
+
+        if len(nearby_friends):
+            other = self.random.choice(nearby_friends)
+            other.wealth += 1
+            self.wealth -= 1
+
+
+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)
+        self.grid = MultiGrid(width, height, False)
+
+        # Create agents
+        for agent in self.agents:
+            x = self.random.randrange(self.grid.width)
+            y = self.random.randrange(self.grid.height)
+            self.grid.place_agent(agent, (x, y))
+
+        self.datacollector = DataCollector(
+            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__':
+
+
+    G = graph_generator()
+    fixed_params = {"topology": G,
+                    "width": 10,
+                    "network_agents": [{"agent_type": 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.run_all()
+
+    run_data = batch_run.get_model_vars_dataframe()
+    run_data.head()
+    print(run_data.Gini)
+

examples/mesa/wealth.py

+from mesa import Agent, Model
+from mesa.space import MultiGrid
+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)
+
+class MoneyAgent(Agent):
+    """ 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)
+        new_position = self.random.choice(possible_steps)
+        self.model.grid.move_agent(self, new_position)
+
+    def give_money(self):
+        cellmates = self.model.grid.get_cell_list_contents([self.pos])
+        if len(cellmates) > 1:
+            other = self.random.choice(cellmates)
+            other.wealth += 1
+            self.wealth -= 1
+
+    def step(self):
+        self.move()
+        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)
+        self.schedule = RandomActivation(self)
+        self.running = True
+
+        # Create agents
+        for i in range(self.num_agents):
+            a = MoneyAgent(i, self)
+            self.schedule.add(a)
+            # Add the agent to a random grid cell
+            x = self.random.randrange(self.grid.width)
+            y = self.random.randrange(self.grid.height)
+            self.grid.place_agent(a, (x, y))
+
+        self.datacollector = DataCollector(
+            model_reporters={"Gini": compute_gini},
+            agent_reporters={"Wealth": "wealth"})
+
+    def step(self):
+        self.datacollector.collect(self)
+        self.schedule.step()
+
+
+if __name__ == '__main__':
+
+    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.run_all()
+
+    run_data = batch_run.get_model_vars_dataframe()
+    run_data.head()
+    print(run_data.Gini)
+

examples/newsspread/NewsSpread.yml

@@ -68,12 +68,12 @@ network_agents:
 - agent_type: HerdViewer
   state:
     has_tv: true
-    id: neutral
+    state_id: neutral
   weight: 1
 - agent_type: HerdViewer
   state:
     has_tv: true
-    id: neutral
+    state_id: neutral
   weight: 1
 network_params:
   generator: barabasi_albert_graph
@@ -95,7 +95,7 @@ network_agents:
 - agent_type: HerdViewer
   state:
     has_tv: true
-    id: neutral
+    state_id: neutral
   weight: 1
 - agent_type: WiseViewer
   state:
@@ -121,7 +121,7 @@ network_agents:
 - agent_type: WiseViewer
   state:
     has_tv: true
-    id: neutral
+    state_id: neutral
   weight: 1
 - agent_type: WiseViewer
   state:

examples/newsspread/newsspread.py

@@ -34,8 +34,6 @@ class HerdViewer(DumbViewer):
     A viewer whose probability of infection depends on the state of its neighbors.
     '''
 
-    level = logging.DEBUG
-
     def infect(self):
         infected = self.count_neighboring_agents(state_id=self.infected.id)
         total = self.count_neighboring_agents()

examples/rabbits/rabbit_agents.py

 from soil.agents import FSM, state, default_state, BaseAgent, NetworkAgent
 from enum import Enum
 from random import random, choice
-from itertools import islice
 import logging
 import math
 
@@ -22,7 +21,7 @@ class RabbitModel(FSM):
         'offspring': 0,
     }
 
-    sexual_maturity = 4*30
+    sexual_maturity = 3 #4*30
     life_expectancy = 365 * 3
     gestation = 33
     pregnancy = -1
@@ -31,9 +30,11 @@ class RabbitModel(FSM):
     @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
@@ -46,8 +47,7 @@ class RabbitModel(FSM):
             return
 
         # Males try to mate
-        females = self.get_agents(state_id=self.fertile.id, gender=Genders.female.value, limit_neighbors=False)
-        for f in islice(females, self.max_females):
+        for f in self.get_agents(state_id=self.fertile.id, gender=Genders.female.value, limit_neighbors=False, limit=self.max_females):
             r = random()
             if r < self['mating_prob']:
                 self.impregnate(f)

examples/rabbits/rabbits.yml

 ---
 load_module: rabbit_agents
 name: rabbits_example
-max_time: 500
+max_time: 150
 interval: 1
 seed: MySeed
 agent_type: RabbitModel

examples/random_delays/random_delays.py

+'''
+Example of setting a 
+Example of a fully programmatic simulation, without definition files.
+'''
+from soil import Simulation, agents
+from soil.time import Delta
+from networkx import Graph
+from random import expovariate
+import logging
+
+
+
+class MyAgent(agents.FSM):
+
+    @agents.default_state
+    @agents.state
+    def neutral(self):
+        self.info('I am running')
+        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()

examples/template.yml

@@ -16,7 +16,7 @@ template:
     - agent_type: CounterModel
       weight: "{{ x1 }}"
       state:
-        id: 0
+        state_id: 0
     - agent_type: AggregatedCounter
       weight: "{{ 1 - x1 }}"
   environment_params:

examples/terrorism/TerroristNetworkModel.py

@@ -18,12 +18,12 @@ class TerroristSpreadModel(FSM, Geo):
         prob_interaction
     """
 
-    def __init__(self, environment=None, agent_id=0, state=()):
-        super().__init__(environment=environment, agent_id=agent_id, state=state)
+    def __init__(self, model=None, unique_id=0, state=()):
+        super().__init__(model=model, unique_id=unique_id, state=state)
 
-        self.information_spread_intensity = environment.environment_params['information_spread_intensity']
-        self.terrorist_additional_influence = environment.environment_params['terrorist_additional_influence']
-        self.prob_interaction = environment.environment_params['prob_interaction']
+        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)
@@ -34,10 +34,10 @@ class TerroristSpreadModel(FSM, Geo):
         else:
             raise Exception('Invalid state id: {}'.format(self['id']))
 
-        if 'min_vulnerability' in environment.environment_params:
-            self.vulnerability = random.uniform( environment.environment_params['min_vulnerability'], environment.environment_params['max_vulnerability'] )
+        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, environment.environment_params['max_vulnerability'] )
+            self.vulnerability = random.uniform( 0, model.environment_params['max_vulnerability'] )
 
 
     @state
@@ -93,11 +93,11 @@ class TrainingAreaModel(FSM, Geo):
     Requires TerroristSpreadModel.
     """
 
-    def __init__(self, environment=None, agent_id=0, state=()):
-        super().__init__(environment=environment, agent_id=agent_id, state=state)
-        self.training_influence = environment.environment_params['training_influence']
-        if 'min_vulnerability' in environment.environment_params:
-            self.min_vulnerability = environment.environment_params['min_vulnerability']
+    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']