v0.20.8 fix bugs

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

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

.dockerignore

@@ -1,2 +1,7 @@
 **/soil_output
 .*
+**/.*
+**/__pycache__
+__pycache__
+*.pyc
+**/backup

.gitignore

@@ -8,3 +8,5 @@ soil_output
 docs/_build*
 build/*
 dist/*
+prof
+backup

.gitlab-ci.yml

@@ -1,9 +1,10 @@
 stages:
   - test
-  - build
+  - publish
+  - check_published
 
-build:
-  stage: build
+docker:
+  stage: publish
   image:
     name: gcr.io/kaniko-project/executor:debug
     entrypoint: [""]
@@ -16,13 +17,37 @@ build:
   only:
     - tags
 
-
 test:
-  except:
-    - tags  # Avoid running tests for tags, because they are already run for the branch
   tags:
     - docker
   image: python:3.7
   stage: test
   script:
-    - python setup.py test
+    - pip install -r requirements.txt -r test-requirements.txt
+    - python setup.py test
+
+push_pypi:
+  only:
+    - tags
+  tags:
+    - docker
+  image: python:3.7
+  stage: publish
+  script:
+    - echo $CI_COMMIT_TAG > soil/VERSION
+    - pip install twine
+    - python setup.py sdist bdist_wheel
+    - TWINE_PASSWORD=$PYPI_PASSWORD TWINE_USERNAME=$PYPI_USERNAME python -m twine upload dist/*
+
+check_pypi:
+  only:
+    - tags
+  tags:
+    - docker
+  image: python:3.7
+  stage: check_published
+  script:
+    - pip install soil==$CI_COMMIT_TAG
+  # Allow PYPI to update its index before we try to install 
+  when: delayed
+  start_in: 2 minutes

CHANGELOG.md

@@ -3,6 +3,115 @@ 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).
 
+## [UNRELEASED]
+
+## [0.20.8]
+### Changed
+* Tsih bumped to version 0.1.8
+### Fixed
+* Mentions to `id` in docs. It should be `state_id` now.
+* Fixed bug: environment agents were not being added to the simulation
+
+## [0.20.7]
+### Changed
+* Creating a `time.When` from another `time.When` does not nest them anymore (it returns the argument)
+### Fixed
+* Bug with time.NEVER/time.INFINITY
+## [0.20.6]
+### Fixed
+* Agents now return `time.INFINITY` when dead, instead of 'inf'
+* `soil.__init__` does not re-export built-in time (change in `soil.simulation`. It used to create subtle import conflicts when importing soil.time.
+* Parallel simulations were broken because lambdas cannot be pickled properly, which is needed for multiprocessing.
+### Changed
+* Some internal simulation methods do not accept `*args` anymore, to avoid ambiguity and bugs.
+## [0.20.5]
+### Changed
+* Defaults are now set in the agent __init__, not in the environment. This decouples both classes a bit more, and it is more intuitive 
+## [0.20.4]
+### Added
+* Agents can now be given any kwargs, which will be used to set their state
+* Environments have a default logger `self.logger` and a log method, just like agents
+## [0.20.3]
+### Fixed
+* Default state values are now deepcopied again.
+* Seeds for environments only concatenate the trial id (i.e., a number), to provide repeatable results.
+* `Environment.run` now calls `Environment.step`, to allow for easy overloading of the environment step
+### Removed
+* Datacollectors are not being used for now.
+* `time.TimedActivation.step` does not use an `until` parameter anymore.
+### Changed
+* Simulations now run right up to `until` (open interval)
+* Time instants (`time.When`) don't need to be floats anymore. Now we can avoid precision issues with big numbers by using ints.
+* Rabbits simulation is more idiomatic (using subclasses)
+
+## [0.20.2]
+### Fixed
+* CI/CD testing issues
+## [0.20.1]
+### Fixed
+* Agents would run another step after dying.
+## [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
+* The configuration file must exist when launching through the CLI. If it doesn't, an error will be logged
+* Minor changes in the documentation of the CLI arguments
+### Changed
+* Stats are now exported by default
+## [0.15.1]
+### Added
+* read-only `History`
+### Fixed
+* Serialization problem with the `Environment` on parallel mode.
+* Analysis functions now work as they should in the tutorial
+## [0.15.0]
+### Added
+* Control logging level in CLI and simulation
+* `Stats` to calculate trial and simulation-wide statistics
+* Simulation statistics are stored in a separate table in history (see `History.get_stats` and `History.save_stats`, as well as `soil.stats`)
+* Aliased `NetworkAgent.G` to `NetworkAgent.topology`.
+### Changed
+* Templates in config files can be given as dictionaries in addition to strings
+* Samplers are used more explicitly
+* Removed nxsim dependency. We had already made a lot of changes, and nxsim has not been updated in 5 years.
+* Exporter methods renamed to `trial` and `end`. Added `start`.
+* `Distribution` exporter now a stats class
+* `global_topology` renamed to `topology`
+* Moved topology-related methods to `NetworkAgent`
+### Fixed
+* Temporary files used for history in dry_run mode are not longer left open 
+
+## [0.14.9]
+### Changed
+* Seed random before environment initialization
+## [0.14.8]
+### Fixed
+* Invalid directory names in Windows gsi-upm/soil#5
+## [0.14.7]
+### Changed
+* Minor change to traceback handling in async simulations
+### Fixed
+* Incomplete example in the docs (example.yml) caused an exception
+## [0.14.6]
+### Fixed
+* Bug with newer versions of networkx (0.24) where the Graph.node attribute has been removed. We have updated our calls, but the code in nxsim is not under our control, so we have pinned the networkx version until that issue is solved.
+### Changed
+* Explicit yaml.SafeLoader to avoid deprecation warnings when using yaml.load. It should not break any existing setups, but we could move to the FullLoader in the future if needed.
+
 ## [0.14.4]
 ### Fixed
 * Bug in `agent.get_agents()` when `state_id` is passed as a string. The tests have been modified accordingly.

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.dit.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/conf.py

@@ -31,7 +31,7 @@
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = []
+extensions = ['IPython.sphinxext.ipython_console_highlighting']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@@ -69,7 +69,7 @@ language = None
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', '**.ipynb_checkpoints']
 
 # The name of the Pygments (syntax highlighting) style to use.
 pygments_style = 'sphinx'

docs/configuration.rst

@@ -8,32 +8,8 @@ The advantage of a configuration file is that it is a clean declarative descript
 Simulation configuration files can be formatted in ``json`` or ``yaml`` and they define all the parameters of a simulation.
 Here's an example (``example.yml``).
 
-.. code:: yaml
-          
-    ---
-    name: MyExampleSimulation
-    max_time: 50
-    num_trials: 3
-    interval: 2
-    network_params:
-        generator: barabasi_albert_graph
-        n: 100
-        m: 2
-    network_agents:
-        - agent_type: SISaModel
-           weight: 1
-            state:
-            id: content
-        - agent_type: SISaModel
-            weight: 1
-            state:
-            id: discontent
-        - agent_type: SISaModel
-            weight: 8
-            state:
-            id: neutral
-    environment_params:
-        prob_infect: 0.075
+.. literalinclude:: example.yml
+   :language: yaml
 
 
 This example configuration will run three trials (``num_trials``) of a simulation containing a randomly generated network (``network_params``).
@@ -242,3 +218,24 @@ These agents are programmed in much the same way as network agents, the only dif
 
 You may use environment agents to model events that a normal agent cannot control, such as natural disasters or chance.
 They are also useful to add behavior that has little to do with the network and the interactions within that network.
+
+Templating
+==========
+
+Sometimes, it is useful to parameterize a simulation and run it over a range of values in order to compare each run and measure the effect of those parameters in the simulation.
+For instance, you may want to run a simulation with different agent distributions.
+
+This can be done in Soil using **templates**.
+A template is a configuration where some of the values are specified with a variable.
+e.g.,  ``weight: "{{ var1 }}"`` instead of ``weight: 1``.
+There are two types of variables, depending on how their values are decided:
+
+* Fixed. A list of values is provided, and a new simulation is run for each possible value. If more than a variable is given, a new simulation will be run per combination of values.
+* Bounded/Sampled. The bounds of the variable are provided, along with a sampler method, which will be used to compute all the configuration combinations.
+
+When fixed and bounded variables are mixed, Soil generates a new configuration per combination of fixed values and bounded values.
+
+Here is an example with a single fixed variable and two bounded variable:
+
+.. literalinclude:: ../examples/template.yml
+   :language: yaml

docs/example.yml

@@ -0,0 +1,35 @@
+---
+name: MyExampleSimulation
+max_time: 50
+num_trials: 3
+interval: 2
+network_params:
+    generator: barabasi_albert_graph
+    n: 100
+    m: 2
+network_agents:
+    - agent_type: SISaModel
+      weight: 1
+      state:
+        id: content
+    - agent_type: SISaModel
+      weight: 1
+      state:
+        id: discontent
+    - agent_type: SISaModel
+      weight: 8
+      state:
+        id: neutral
+environment_params:
+    prob_infect: 0.075
+    neutral_discontent_spon_prob: 0.1
+    neutral_discontent_infected_prob: 0.3
+    neutral_content_spon_prob: 0.3
+    neutral_content_infected_prob: 0.4
+    discontent_neutral: 0.5
+    discontent_content: 0.5
+    variance_d_c: 0.2
+    content_discontent: 0.2
+    variance_c_d: 0.2
+    content_neutral: 0.2
+    standard_variance: 1

docs/installation.rst

@@ -14,11 +14,11 @@ Now test that it worked by running the command line tool
 
    soil --help
 
-Or using soil programmatically:
+Or, if you're using using soil programmatically:
 
 .. code:: python
 
    import soil
    print(soil.__version__)
 
-The latest version can be installed through `GitLab <https://lab.cluster.gsi.dit.upm.es/soil/soil.git>`_.
+The latest version can be installed through `GitLab <https://lab.gsi.upm.es/soil/soil.git>`_ or `GitHub <https://github.com/gsi-upm/soil>`_.

docs/requirements.txt

@@ -0,0 +1 @@
+ipython==7.31.1

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

@@ -0,0 +1,21 @@
+---
+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

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,120 @@
+'''
+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

@@ -0,0 +1,83 @@
+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.ipynb

@@ -2,13 +2,12 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 1,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-11-08T16:22:30.732107Z",
      "start_time": "2017-11-08T17:22:30.059855+01:00"
-    },
-    "collapsed": true
+    }
    },
    "outputs": [],
    "source": [
@@ -28,24 +27,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 2,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-11-08T16:22:35.580593Z",
      "start_time": "2017-11-08T17:22:35.542745+01:00"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Populating the interactive namespace from numpy and matplotlib\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "%pylab inline\n",
+    "%matplotlib inline\n",
     "\n",
     "from soil import *"
    ]
@@ -66,7 +57,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 3,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-11-08T16:22:37.242327Z",
@@ -86,7 +77,7 @@
       "  prob_neighbor_spread: 0.0\r\n",
       "  prob_tv_spread: 0.01\r\n",
       "interval: 1\r\n",
-      "max_time: 30\r\n",
+      "max_time: 300\r\n",
       "name: Sim_all_dumb\r\n",
       "network_agents:\r\n",
       "- agent_type: DumbViewer\r\n",
@@ -110,7 +101,7 @@
       "  prob_neighbor_spread: 0.0\r\n",
       "  prob_tv_spread: 0.01\r\n",
       "interval: 1\r\n",
-      "max_time: 30\r\n",
+      "max_time: 300\r\n",
       "name: Sim_half_herd\r\n",
       "network_agents:\r\n",
       "- agent_type: DumbViewer\r\n",
@@ -142,18 +133,18 @@
       "  prob_neighbor_spread: 0.0\r\n",
       "  prob_tv_spread: 0.01\r\n",
       "interval: 1\r\n",
-      "max_time: 30\r\n",
+      "max_time: 300\r\n",
       "name: Sim_all_herd\r\n",
       "network_agents:\r\n",
       "- agent_type: HerdViewer\r\n",
       "  state:\r\n",
       "    has_tv: true\r\n",
-      "    id: neutral\r\n",
+      "    state_id: neutral\r\n",
       "  weight: 1\r\n",
       "- agent_type: HerdViewer\r\n",
       "  state:\r\n",
       "    has_tv: true\r\n",
-      "    id: neutral\r\n",
+      "    state_id: neutral\r\n",
       "  weight: 1\r\n",
       "network_params:\r\n",
       "  generator: barabasi_albert_graph\r\n",
@@ -169,13 +160,13 @@
       "  prob_tv_spread: 0.01\r\n",
       "  prob_neighbor_cure: 0.1\r\n",
       "interval: 1\r\n",
-      "max_time: 30\r\n",
+      "max_time: 300\r\n",
       "name: Sim_wise_herd\r\n",
       "network_agents:\r\n",
       "- agent_type: HerdViewer\r\n",
       "  state:\r\n",
       "    has_tv: true\r\n",
-      "    id: neutral\r\n",
+      "    state_id: neutral\r\n",
       "  weight: 1\r\n",
       "- agent_type: WiseViewer\r\n",
       "  state:\r\n",
@@ -195,13 +186,13 @@
       "  prob_tv_spread: 0.01\r\n",
       "  prob_neighbor_cure: 0.1\r\n",
       "interval: 1\r\n",
-      "max_time: 30\r\n",
+      "max_time: 300\r\n",
       "name: Sim_all_wise\r\n",
       "network_agents:\r\n",
       "- agent_type: WiseViewer\r\n",
       "  state:\r\n",
       "    has_tv: true\r\n",
-      "    id: neutral\r\n",
+      "    state_id: neutral\r\n",
       "  weight: 1\r\n",
       "- agent_type: WiseViewer\r\n",
       "  state:\r\n",
@@ -225,7 +216,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 4,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-11-08T18:07:46.781745Z",
@@ -233,7 +224,24 @@
     },
     "scrolled": true
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "No objects to concatenate",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[4], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m evodumb \u001b[38;5;241m=\u001b[39m \u001b[43manalysis\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_data\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43msoil_output/Sim_all_dumb/\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprocess\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43manalysis\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_count\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgroup\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mid\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m;\n",
+      "File \u001b[0;32m/mnt/data/home/j/git/lab.gsi/soil/soil/soil/analysis.py:14\u001b[0m, in \u001b[0;36mread_data\u001b[0;34m(group, *args, **kwargs)\u001b[0m\n\u001b[1;32m     12\u001b[0m iterable \u001b[38;5;241m=\u001b[39m _read_data(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m     13\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m group:\n\u001b[0;32m---> 14\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgroup_trials\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterable\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     15\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m     16\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(iterable)\n",
+      "File \u001b[0;32m/mnt/data/home/j/git/lab.gsi/soil/soil/soil/analysis.py:201\u001b[0m, in \u001b[0;36mgroup_trials\u001b[0;34m(trials, aggfunc)\u001b[0m\n\u001b[1;32m    199\u001b[0m trials \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(trials)\n\u001b[1;32m    200\u001b[0m trials \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28;01mlambda\u001b[39;00m x: x[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(x, \u001b[38;5;28mtuple\u001b[39m) \u001b[38;5;28;01melse\u001b[39;00m x, trials))\n\u001b[0;32m--> 201\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconcat\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrials\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mgroupby(level\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\u001b[38;5;241m.\u001b[39magg(aggfunc)\u001b[38;5;241m.\u001b[39mreorder_levels([\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m1\u001b[39m] ,axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n",
+      "File \u001b[0;32m/mnt/data/home/j/git/lab.gsi/soil/soil/.env-v0.20/lib/python3.8/site-packages/pandas/util/_decorators.py:331\u001b[0m, in \u001b[0;36mdeprecate_nonkeyword_arguments.<locals>.decorate.<locals>.wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    325\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(args) \u001b[38;5;241m>\u001b[39m num_allow_args:\n\u001b[1;32m    326\u001b[0m     warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m    327\u001b[0m         msg\u001b[38;5;241m.\u001b[39mformat(arguments\u001b[38;5;241m=\u001b[39m_format_argument_list(allow_args)),\n\u001b[1;32m    328\u001b[0m         \u001b[38;5;167;01mFutureWarning\u001b[39;00m,\n\u001b[1;32m    329\u001b[0m         stacklevel\u001b[38;5;241m=\u001b[39mfind_stack_level(),\n\u001b[1;32m    330\u001b[0m     )\n\u001b[0;32m--> 331\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m/mnt/data/home/j/git/lab.gsi/soil/soil/.env-v0.20/lib/python3.8/site-packages/pandas/core/reshape/concat.py:368\u001b[0m, in \u001b[0;36mconcat\u001b[0;34m(objs, axis, join, ignore_index, keys, levels, names, verify_integrity, sort, copy)\u001b[0m\n\u001b[1;32m    146\u001b[0m \u001b[38;5;129m@deprecate_nonkeyword_arguments\u001b[39m(version\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, allowed_args\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mobjs\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[1;32m    147\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mconcat\u001b[39m(\n\u001b[1;32m    148\u001b[0m     objs: Iterable[NDFrame] \u001b[38;5;241m|\u001b[39m Mapping[HashableT, NDFrame],\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    157\u001b[0m     copy: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    158\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m DataFrame \u001b[38;5;241m|\u001b[39m Series:\n\u001b[1;32m    159\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    160\u001b[0m \u001b[38;5;124;03m    Concatenate pandas objects along a particular axis.\u001b[39;00m\n\u001b[1;32m    161\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    366\u001b[0m \u001b[38;5;124;03m    1   3   4\u001b[39;00m\n\u001b[1;32m    367\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 368\u001b[0m     op \u001b[38;5;241m=\u001b[39m \u001b[43m_Concatenator\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    369\u001b[0m \u001b[43m        \u001b[49m\u001b[43mobjs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    370\u001b[0m \u001b[43m        \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    371\u001b[0m \u001b[43m        \u001b[49m\u001b[43mignore_index\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mignore_index\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    372\u001b[0m \u001b[43m        \u001b[49m\u001b[43mjoin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    373\u001b[0m \u001b[43m        \u001b[49m\u001b[43mkeys\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkeys\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    374\u001b[0m \u001b[43m        \u001b[49m\u001b[43mlevels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlevels\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    375\u001b[0m \u001b[43m        \u001b[49m\u001b[43mnames\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnames\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    376\u001b[0m \u001b[43m        \u001b[49m\u001b[43mverify_integrity\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverify_integrity\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    377\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    378\u001b[0m \u001b[43m        \u001b[49m\u001b[43msort\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msort\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    379\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    381\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m op\u001b[38;5;241m.\u001b[39mget_result()\n",
+      "File \u001b[0;32m/mnt/data/home/j/git/lab.gsi/soil/soil/.env-v0.20/lib/python3.8/site-packages/pandas/core/reshape/concat.py:425\u001b[0m, in \u001b[0;36m_Concatenator.__init__\u001b[0;34m(self, objs, axis, join, keys, levels, names, ignore_index, verify_integrity, copy, sort)\u001b[0m\n\u001b[1;32m    422\u001b[0m     objs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(objs)\n\u001b[1;32m    424\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(objs) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 425\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo objects to concatenate\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    427\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m keys \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    428\u001b[0m     objs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(com\u001b[38;5;241m.\u001b[39mnot_none(\u001b[38;5;241m*\u001b[39mobjs))\n",
+      "\u001b[0;31mValueError\u001b[0m: No objects to concatenate"
+     ]
+    }
+   ],
    "source": [
     "evodumb = analysis.read_data('soil_output/Sim_all_dumb/', process=analysis.get_count, group=True, keys=['id']);"
    ]
@@ -721,9 +729,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "venv-soil",
    "language": "python",
-   "name": "python3"
+   "name": "venv-soil"
   },
   "language_info": {
    "codemirror_mode": {
@@ -735,7 +743,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.2"
+   "version": "3.8.10"
   },
   "toc": {
    "colors": {

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

@@ -17,7 +17,7 @@ class DumbViewer(FSM):
     def neutral(self):
         if self['has_tv']:
             if prob(self.env['prob_tv_spread']):
-                self.set_state(self.infected)
+                return self.infected
 
     @state
     def infected(self):
@@ -26,6 +26,12 @@ class DumbViewer(FSM):
                 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)
 
 
@@ -34,15 +40,14 @@ class HerdViewer(DumbViewer):
     A viewer whose probability of infection depends on the state of its neighbors.
     '''
 
-    level = logging.DEBUG
-
     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.id)
+            self.set_state(self.infected)
 
 
 class WiseViewer(HerdViewer):
@@ -77,5 +82,5 @@ class WiseViewer(HerdViewer):
                        1.0)
         prob_cure = self.env['prob_neighbor_cure'] * (cured/infected)
         if prob(prob_cure):
-            return self.cure()
+            return self.cured
         return self.set_state(super().infected)

examples/programmatic/programmatic.py

@@ -18,7 +18,9 @@ class MyAgent(agents.FSM):
     @agents.default_state
     @agents.state
     def neutral(self):
-        self.info('I am running')
+        self.debug('I am running')
+        if agents.prob(0.2):
+            self.info('This runs 2/10 times on average')
 
 
 s = Simulation(name='Programmatic',
@@ -29,10 +31,10 @@ s = Simulation(name='Programmatic',
                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()
 
-s.dump_yaml()
-
-for env in envs:
-    env.dump_csv()
+# Uncomment this to output the simulation to a YAML file
+# s.dump_yaml('simulation.yaml')

examples/rabbits/rabbit_agents.py

@@ -1,7 +1,6 @@
-from soil.agents import FSM, state, default_state, BaseAgent
+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
 
@@ -13,8 +12,6 @@ class Genders(Enum):
 
 class RabbitModel(FSM):
 
-    level = logging.INFO
-
     defaults = {
         'age': 0,
         'gender': Genders.male.value,
@@ -22,7 +19,7 @@ class RabbitModel(FSM):
         'offspring': 0,
     }
 
-    sexual_maturity = 4*30
+    sexual_maturity = 3 #4*30
     life_expectancy = 365 * 3
     gestation = 33
     pregnancy = -1
@@ -31,10 +28,23 @@ 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
+    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):
@@ -46,21 +56,26 @@ 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=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):
-        if self['gender'] == Genders.female.value:
-            raise NotImplementedError('Females cannot impregnate')
         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
@@ -80,7 +95,7 @@ class RabbitModel(FSM):
                 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.global_topology.number_of_nodes())+1
+                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
@@ -90,19 +105,19 @@ class RabbitModel(FSM):
 
     @state
     def dead(self):
-        self.info('Agent {} is dying'.format(self.id))
+        super().dead()
         if 'pregnancy' in self and self['pregnancy'] > -1:
             self.info('A mother has died carrying a baby!!')
-        self.die()
-        return
 
 
-class RandomAccident(BaseAgent):
+class RandomAccident(NetworkAgent):
 
     level = logging.DEBUG
 
     def step(self):
-        rabbits_total = self.global_topology.number_of_nodes()
+        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))
@@ -116,5 +131,5 @@ class RandomAccident(BaseAgent):
                 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.global_topology.number_of_nodes():
+        if self.count_agents(state_id=RabbitModel.dead.id) == self.topology.number_of_nodes():
             self.die()

examples/rabbits/rabbits.yml

@@ -1,23 +1,21 @@
 ---
 load_module: rabbit_agents
 name: rabbits_example
-max_time: 500
+max_time: 1000
 interval: 1
 seed: MySeed
-agent_type: RabbitModel
+agent_type: rabbit_agents.RabbitModel
 environment_agents:
-    - agent_type: RandomAccident
+    - agent_type: rabbit_agents.RandomAccident
 environment_params:
   prob_death: 0.001
 default_state:
-  mating_prob: 0.01
+  mating_prob: 0.1
 topology:
   nodes:
     - id: 1
-      state:
-        gender: female
+      agent_type: rabbit_agents.Male
     - id: 0
-      state:
-        gender: male
+      agent_type: rabbit_agents.Female
   directed: true
   links: []

examples/random_delays/random_delays.py

@@ -0,0 +1,45 @@
+'''
+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()

examples/template.yml

@@ -1,13 +1,8 @@
 ---
-vars:
-  bounds:
-    x1: [0, 1]
-    x2: [1, 2]
-  fixed:
-    x3: ["a", "b", "c"]
-sampler: "SALib.sample.morris.sample"
-samples: 10
-template: |
+sampler:
+  method: "SALib.sample.morris.sample"
+  N: 10
+template:
   group: simple
   num_trials: 1
   interval: 1
@@ -19,11 +14,17 @@ template: |
     n: 10
   network_agents:
     - agent_type: CounterModel
-      weight: {{ x1 }}
+      weight: "{{ x1 }}"
       state:
-        id: 0
+        state_id: 0
     - agent_type: AggregatedCounter
-      weight: {{ 1 - x1 }}
+      weight: "{{ 1 - x1 }}"
   environment_params:
-    name: {{ x3 }}
+    name: "{{ x3 }}"
   skip_test: true
+vars:
+  bounds:
+    x1: [0, 1]
+    x2: [1, 2]
+  fixed:
+    x3: ["a", "b", "c"]

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']
         else: self.min_vulnerability = 0
 
     @default_state
@@ -120,13 +120,13 @@ class HavenModel(FSM, Geo):
     Requires TerroristSpreadModel.
     """
 
-    def __init__(self, environment=None, agent_id=0, state=()):
-        super().__init__(environment=environment, agent_id=agent_id, state=state)
-        self.haven_influence = environment.environment_params['haven_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.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 = environment.environment_params['max_vulnerability']
+        self.max_vulnerability = model.environment_params['max_vulnerability']
 
     def get_occupants(self, **kwargs):
         return self.get_neighboring_agents(agent_type=TerroristSpreadModel, **kwargs)
@@ -162,13 +162,13 @@ class TerroristNetworkModel(TerroristSpreadModel):
         weight_link_distance
     """
 
-    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.vision_range = environment.environment_params['vision_range']
-        self.sphere_influence = environment.environment_params['sphere_influence']
-        self.weight_social_distance = environment.environment_params['weight_social_distance']
-        self.weight_link_distance = environment.environment_params['weight_link_distance']
+        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):
@@ -195,14 +195,14 @@ class TerroristNetworkModel(TerroristSpreadModel):
                     break
 
     def get_distance(self, target):
-        source_x, source_y = nx.get_node_attributes(self.global_topology, 'pos')[self.id]
-        target_x, target_y = nx.get_node_attributes(self.global_topology, 'pos')[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.global_topology, self.id, target)
+            return nx.shortest_path_length(self.topology, self.id, target)
         except nx.NetworkXNoPath:
             return float('inf')

requirements.txt

@@ -1,10 +1,9 @@
-nxsim>=0.1.2
-simpy
-networkx>=2.0
+networkx>=2.5
 numpy
 matplotlib
 pyyaml>=5.1
 pandas>=0.23
-scipy==1.2.1 # scipy 1.3.0rc1 is not compatible with salib
 SALib>=1.3
 Jinja2
+Mesa>=0.8
+tsih>=0.1.9

setup.py

@@ -16,6 +16,12 @@ def parse_requirements(filename):
 
 install_reqs = parse_requirements("requirements.txt")
 test_reqs = parse_requirements("test-requirements.txt")
+extras_require={
+    'mesa': ['mesa>=0.8.9'],
+    'geo': ['scipy>=1.3'],
+    'web': ['tornado']
+}
+extras_require['all'] = [dep for package in extras_require.values() for dep in package]
 
 
 setup(
@@ -40,10 +46,7 @@ setup(
         'Operating System :: POSIX',
         'Programming Language :: Python :: 3'],
     install_requires=install_reqs,
-    extras_require={
-        'web': ['tornado']
-
-    },
+    extras_require=extras_require,
     tests_require=test_reqs,
     setup_requires=['pytest-runner', ],
     include_package_data=True,

soil/VERSION

@@ -1 +1 @@
-0.14.4
+0.20.8

soil/__init__.py

@@ -11,25 +11,28 @@ try:
 except NameError:
     basestring = str
 
+from .agents import *
 from . import agents
 from .simulation import *
 from .environment import Environment
-from .history import History
 from . import serialization
 from . import analysis
+from .utils import logger
+from .time import *
 
 def main():
     import argparse
     from . import simulation
 
-    logging.basicConfig(level=logging.INFO)
-    logging.info('Running SOIL version: {}'.format(__version__))
+    logger.info('Running SOIL version: {}'.format(__version__))
 
     parser = argparse.ArgumentParser(description='Run a SOIL simulation')
     parser.add_argument('file', type=str,
                         nargs="?",
                         default='simulation.yml',
-                        help='python module containing the simulation configuration.')
+                        help='Configuration file for the simulation (e.g., YAML or JSON)')
+    parser.add_argument('--version', action='store_true',
+                        help='Show version info and exit')
     parser.add_argument('--module', '-m', type=str,
                         help='file containing the code of any custom agents.')
     parser.add_argument('--dry-run', '--dry', action='store_true',
@@ -40,6 +43,8 @@ def main():
                         help='Dump GEXF graph. Defaults to false.')
     parser.add_argument('--csv', action='store_true',
                         help='Dump history in CSV format. Defaults to false.')
+    parser.add_argument('--level', type=str,
+                        help='Logging level')
     parser.add_argument('--output', '-o', type=str, default="soil_output",
                         help='folder to write results to. It defaults to the current directory.')
     parser.add_argument('--synchronous', action='store_true',
@@ -48,13 +53,21 @@ def main():
                         help='Export environment and/or simulations using this exporter')
 
     args = parser.parse_args()
+    logging.basicConfig(level=getattr(logging, (args.level or 'INFO').upper()))
+
+    if args.version:
+        return
 
     if os.getcwd() not in sys.path:
         sys.path.append(os.getcwd())
     if args.module:
         importlib.import_module(args.module)
 
-    logging.info('Loading config file: {}'.format(args.file))
+    logger.info('Loading config file: {}'.format(args.file))
+
+    if args.pdb:
+        args.synchronous = True
+
 
     try:
         exporters = list(args.exporter or ['default', ])
@@ -65,6 +78,10 @@ def main():
         exp_params = {}
         if args.dry_run:
             exp_params['copy_to'] = sys.stdout
+
+        if not os.path.exists(args.file):
+            logger.error('Please, input a valid file')
+            return
         simulation.run_from_config(args.file,
                                    dry_run=args.dry_run,
                                    exporters=exporters,

soil/agents/BassModel.py

@@ -1,40 +1,31 @@
 import random
-from . import BaseAgent
+from . import FSM, state, default_state
 
 
-class BassModel(BaseAgent):
+class BassModel(FSM):
     """
     Settings:
         innovation_prob
         imitation_prob
     """
-
-    def __init__(self, environment, agent_id, state):
-        super().__init__(environment=environment, agent_id=agent_id, state=state)
-        env_params = environment.environment_params
-        self.state['sentimentCorrelation'] = 0
+    sentimentCorrelation = 0
 
     def step(self):
         self.behaviour()
 
-    def behaviour(self):
-        # Outside effects
-        if random.random() < self.state_params['innovation_prob']:
-            if self.state['id'] == 0:
-                self.state['id'] = 1
-                self.state['sentimentCorrelation'] = 1
-            else:
-                pass
-
-            return
-
-        # Imitation effects
-        if self.state['id'] == 0:
-            aware_neighbors = self.get_neighboring_agents(state_id=1)
+    @default_state
+    @state
+    def innovation(self):
+        if random.random() < self.innovation_prob:
+            self.sentimentCorrelation = 1
+            return self.aware
+        else:
+            aware_neighbors = self.get_neighboring_agents(state_id=self.aware.id)
             num_neighbors_aware = len(aware_neighbors)
-            if random.random() < (self.state_params['imitation_prob']*num_neighbors_aware):
-                self.state['id'] = 1
-                self.state['sentimentCorrelation'] = 1
+            if random.random() < (self['imitation_prob']*num_neighbors_aware):
+                self.sentimentCorrelation = 1
+                return self.aware
 
-            else:
-                pass
+    @state
+    def aware(self):
+        self.die()

soil/agents/BigMarketModel.py

@@ -1,8 +1,8 @@
 import random
-from . import BaseAgent
+from . import FSM, state, default_state
 
 
-class BigMarketModel(BaseAgent):
+class BigMarketModel(FSM):
     """
     Settings:
         Names:
@@ -19,34 +19,25 @@ class BigMarketModel(BaseAgent):
             sentiment_about [Array]
     """
 
-    def __init__(self, environment=None, agent_id=0, state=()):
-        super().__init__(environment=environment, agent_id=agent_id, state=state)
-        self.enterprises = environment.environment_params['enterprises']
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.enterprises = self.env.environment_params['enterprises']
         self.type = ""
-        self.number_of_enterprises = len(environment.environment_params['enterprises'])
 
-        if self.id < self.number_of_enterprises:  # Enterprises
-            self.state['id'] = self.id
+        if self.id < len(self.enterprises):  # Enterprises
+            self.set_state(self.enterprise.id)
             self.type = "Enterprise"
             self.tweet_probability = environment.environment_params['tweet_probability_enterprises'][self.id]
         else:  # normal users
-            self.state['id'] = self.number_of_enterprises
             self.type = "User"
+            self.set_state(self.user.id)
             self.tweet_probability = environment.environment_params['tweet_probability_users']
             self.tweet_relevant_probability = environment.environment_params['tweet_relevant_probability']
             self.tweet_probability_about = environment.environment_params['tweet_probability_about']  # List
             self.sentiment_about = environment.environment_params['sentiment_about']  # List
 
-    def step(self):
-
-        if self.id < self.number_of_enterprises:  # Enterprise
-            self.enterpriseBehaviour()
-        else:  # Usuario
-            self.userBehaviour()
-            for i in range(self.number_of_enterprises):  # So that it never is set to 0 if there are not changes (logs)
-                self.attrs['sentiment_enterprise_%s'% self.enterprises[i]] = self.sentiment_about[i]
-
-    def enterpriseBehaviour(self):
+    @state
+    def enterprise(self):
 
         if random.random() < self.tweet_probability:  # Tweets
             aware_neighbors = self.get_neighboring_agents(state_id=self.number_of_enterprises)  # Nodes neighbour users
@@ -64,12 +55,12 @@ class BigMarketModel(BaseAgent):
 
                 x.attrs['sentiment_enterprise_%s'% self.enterprises[self.id]] = x.sentiment_about[self.id]
 
-    def userBehaviour(self):
-
+    @state
+    def user(self):
         if random.random() < self.tweet_probability:  # Tweets
             if random.random() < self.tweet_relevant_probability:  # Tweets something relevant
                 # Tweet probability per enterprise
-                for i in range(self.number_of_enterprises):
+                for i in range(len(self.enterprises)):
                     random_num = random.random()
                     if random_num < self.tweet_probability_about[i]:
                         # The condition is fulfilled, sentiments are evaluated towards that enterprise
@@ -82,8 +73,10 @@ class BigMarketModel(BaseAgent):
                         else:
                             # POSITIVO
                             self.userTweets("positive",i)
+        for i in range(len(self.enterprises)):  # So that it never is set to 0 if there are not changes (logs)
+            self.attrs['sentiment_enterprise_%s'% self.enterprises[i]] = self.sentiment_about[i]
 
-    def userTweets(self,sentiment,enterprise):
+    def userTweets(self, sentiment,enterprise):
         aware_neighbors = self.get_neighboring_agents(state_id=self.number_of_enterprises)  # Nodes neighbours users
         for x in aware_neighbors:
             if sentiment == "positive":

soil/agents/CounterModel.py

@@ -1,7 +1,7 @@
-from . import BaseAgent
+from . import NetworkAgent
 
 
-class CounterModel(BaseAgent):
+class CounterModel(NetworkAgent):
     """
     Dummy behaviour. It counts the number of nodes in the network and neighbors
     in each step and adds it to its state.
@@ -9,14 +9,14 @@ class CounterModel(BaseAgent):
 
     def step(self):
         # Outside effects
-        total = len(list(self.get_all_agents()))
+        total = len(list(self.get_agents()))
         neighbors = len(list(self.get_neighboring_agents()))
         self['times'] = self.get('times', 0) + 1
         self['neighbors'] = neighbors
         self['total'] = total
 
 
-class AggregatedCounter(BaseAgent):
+class AggregatedCounter(NetworkAgent):
     """
     Dummy behaviour. It counts the number of nodes in the network and neighbors
     in each step and adds it to its state.
@@ -33,6 +33,6 @@ class AggregatedCounter(BaseAgent):
         self['times'] += 1
         neighbors = len(list(self.get_neighboring_agents()))
         self['neighbors'] += neighbors
-        total = len(list(self.get_all_agents()))
+        total = len(list(self.get_agents()))
         self['total'] += total
         self.debug('Running for step: {}. Total: {}'.format(self.now, total))

soil/agents/Geo.py

@@ -0,0 +1,21 @@
+from scipy.spatial import cKDTree as KDTree
+import networkx as nx
+from . import NetworkAgent, as_node
+
+class Geo(NetworkAgent):
+    '''In this type of network, nodes have a "pos" attribute.'''
+
+    def geo_search(self, radius, node=None, center=False, **kwargs):
+        '''Get a list of nodes whose coordinates are closer than *radius* to *node*.'''
+        node = as_node(node if node is not None else self)
+
+        G = self.subgraph(**kwargs)
+
+        pos = nx.get_node_attributes(G, 'pos')
+        if not pos:
+            return []
+        nodes, coords = list(zip(*pos.items()))
+        kdtree = KDTree(coords)  # Cannot provide generator.
+        indices = kdtree.query_ball_point(pos[node], radius)
+        return [nodes[i] for i in indices if center or (nodes[i] != node)]
+

soil/agents/IndependentCascadeModel.py

@@ -10,10 +10,10 @@ class IndependentCascadeModel(BaseAgent):
         imitation_prob
     """
 
-    def __init__(self, environment=None, agent_id=0, state=()):
-        super().__init__(environment=environment, agent_id=agent_id, state=state)
-        self.innovation_prob = environment.environment_params['innovation_prob']
-        self.imitation_prob = environment.environment_params['imitation_prob']
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.innovation_prob = self.env.environment_params['innovation_prob']
+        self.imitation_prob = self.env.environment_params['imitation_prob']
         self.state['time_awareness'] = 0
         self.state['sentimentCorrelation'] = 0
 

soil/agents/ModelM2.py

@@ -21,8 +21,8 @@ class SpreadModelM2(BaseAgent):
         prob_generate_anti_rumor
     """
 
-    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=environment, unique_id=unique_id, state=state)
 
         self.prob_neutral_making_denier = np.random.normal(environment.environment_params['prob_neutral_making_denier'],
                                                            environment.environment_params['standard_variance'])
@@ -123,8 +123,8 @@ class ControlModelM2(BaseAgent):
     """
 
 
-    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=environment, unique_id=unique_id, state=state)
 
         self.prob_neutral_making_denier = np.random.normal(environment.environment_params['prob_neutral_making_denier'],
                                                            environment.environment_params['standard_variance'])

soil/agents/SISaModel.py

@@ -29,8 +29,8 @@ class SISaModel(FSM):
         standard_variance
     """
 
-    def __init__(self, environment, agent_id=0, state=()):
-        super().__init__(environment=environment, agent_id=agent_id, state=state)
+    def __init__(self, environment, unique_id=0, state=()):
+        super().__init__(model=environment, unique_id=unique_id, state=state)
 
         self.neutral_discontent_spon_prob = np.random.normal(self.env['neutral_discontent_spon_prob'],
                                                              self.env['standard_variance'])

soil/agents/SentimentCorrelationModel.py

@@ -16,8 +16,8 @@ class SentimentCorrelationModel(BaseAgent):
         disgust_prob
     """
 
-    def __init__(self, environment, agent_id=0, state=()):
-        super().__init__(environment=environment, agent_id=agent_id, state=state)
+    def __init__(self, environment, unique_id=0, state=()):
+        super().__init__(model=environment, unique_id=unique_id, state=state)
         self.outside_effects_prob = environment.environment_params['outside_effects_prob']
         self.anger_prob = environment.environment_params['anger_prob']
         self.joy_prob = environment.environment_params['joy_prob']

soil/agents/__init__.py

@@ -1,21 +1,16 @@
-# networkStatus = {}  # Dict that will contain the status of every agent in the network
-# sentimentCorrelationNodeArray = []
-# for x in range(0, settings.network_params["number_of_nodes"]):
-#     sentimentCorrelationNodeArray.append({'id': x})
-# Initialize agent states. Let's assume everyone is normal.
-    
-
-import nxsim
 import logging
-from collections import OrderedDict
+from collections import OrderedDict, defaultdict
 from copy import deepcopy
-from functools import partial
-from scipy.spatial import cKDTree as KDTree
+from functools import partial, wraps
+from itertools import islice
 import json
+import networkx as nx
 
-from functools import wraps
+from .. import serialization, utils, time
 
-from .. import serialization, history
+from tsih import Key
+
+from mesa import Agent
 
 
 def as_node(agent):
@@ -23,41 +18,62 @@ def as_node(agent):
         return agent.id
     return agent
 
+IGNORED_FIELDS = ('model', 'logger')
 
-class BaseAgent(nxsim.BaseAgent):
+
+class DeadAgent(Exception):
+    pass
+
+class BaseAgent(Agent):
     """
-    A special simpy BaseAgent that keeps track of its state history.
+    A special Agent that keeps track of its state history.
     """
 
     defaults = {}
 
-    def __init__(self, environment, agent_id, state=None,
-                 name=None, interval=None, **state_params):
+    def __init__(self,
+                 unique_id,
+                 model,
+                 name=None,
+                 interval=None,
+                 **kwargs
+    ):
         # Check for REQUIRED arguments
-        assert environment is not None, TypeError('__init__ missing 1 required keyword argument: \'environment\'. '
-                                                  'Cannot be NoneType.')
         # Initialize agent parameters
-        self.id = agent_id
-        self.name = name or '{}[{}]'.format(type(self).__name__, self.id)
-        self.state_params = state_params
-
-        # Register agent to environment
-        self.env = environment
+        if isinstance(unique_id, Agent):
+            raise Exception()
+        self._saved = set()
+        super().__init__(unique_id=unique_id, model=model)
+        self.name = name or '{}[{}]'.format(type(self).__name__, self.unique_id)
 
         self._neighbors = None
         self.alive = True
-        real_state = deepcopy(self.defaults)
-        real_state.update(state or {})
-        self.state = real_state
-        self.interval = interval
 
-        if not hasattr(self, 'level'):
-            self.level = logging.DEBUG
-        self.logger = logging.getLogger(self.env.name)
-        self.logger.setLevel(self.level)
+        self.interval = interval or self.get('interval', 1)
+        self.logger = logging.getLogger(self.model.name).getChild(self.name)
 
-        # initialize every time an instance of the agent is created
-        self.action = self.env.process(self.run())
+        if hasattr(self, 'level'):
+            self.logger.setLevel(self.level)
+        for (k, v) in self.defaults.items():
+            if not hasattr(self, k) or getattr(self, k) is None:
+                setattr(self, k, deepcopy(v))
+
+        for (k, v) in kwargs.items():
+            setattr(self, k, v)
+
+
+    # TODO: refactor to clean up mesa compatibility
+    @property
+    def id(self):
+        return self.unique_id
+
+    @property
+    def env(self):
+        return self.model
+
+    @env.setter
+    def env(self, model):
+        self.model = model
 
     @property
     def state(self):
@@ -71,44 +87,47 @@ class BaseAgent(nxsim.BaseAgent):
 
     @state.setter
     def state(self, value):
-        self._state = {}
         for k, v in value.items():
             self[k] = v
 
-    @property
-    def global_topology(self):
-        return self.env.G
-    
     @property
     def environment_params(self):
-        return self.env.environment_params
-    
+        return self.model.environment_params
+
     @environment_params.setter
     def environment_params(self, value):
-        self.env.environment_params = value
+        self.model.environment_params = value
+
+    def __setattr__(self, key, value):
+        if not key.startswith('_') and key not in IGNORED_FIELDS:
+            try:
+                k = Key(t_step=self.now,
+                        dict_id=self.unique_id,
+                        key=key)
+                self._saved.add(key)
+                self.model[k] = value
+            except AttributeError:
+                pass
+        super().__setattr__(key, value)
 
     def __getitem__(self, key):
         if isinstance(key, tuple):
             key, t_step = key
-            k = history.Key(key=key, t_step=t_step, agent_id=self.id)
-            return self.env[k]
-        return self._state.get(key, None)
+            k = Key(key=key, t_step=t_step, dict_id=self.unique_id)
+            return self.model[k]
+        return getattr(self, key)
 
     def __delitem__(self, key):
-        self._state[key] = None
+        return delattr(self, key)
 
     def __contains__(self, key):
-        return key in self._state
+        return hasattr(self, key)
 
     def __setitem__(self, key, value):
-        self._state[key] = value
-        k = history.Key(t_step=self.now,
-                        agent_id=self.id,
-                        key=key)
-        self.env[k] = value
+        setattr(self, key, value)
 
     def items(self):
-        return self._state.items()
+        return ((k, getattr(self, k)) for k in self._saved)
 
     def get(self, key, default=None):
         return self[key] if key in self else default
@@ -116,54 +135,34 @@ class BaseAgent(nxsim.BaseAgent):
     @property
     def now(self):
         try:
-            return self.env.now
+            return self.model.now
         except AttributeError:
             # No environment
             return None
 
-    def run(self):
-        if self.interval is not None:
-            interval = self.interval
-        elif 'interval' in self:
-            interval = self['interval']
-        else:
-            interval = self.env.interval
-        while self.alive:
-            res = self.step()
-            yield res or self.env.timeout(interval)
-
     def die(self, remove=False):
+        self.info(f'agent {self.unique_id}  is dying')
         self.alive = False
         if remove:
-            super().die()
+            self.remove_node(self.id)
+        return time.NEVER
 
     def step(self):
-        pass
-
-    def count_agents(self, **kwargs):
-        return len(list(self.get_agents(**kwargs)))
-
-    def count_neighboring_agents(self, state_id=None, **kwargs):
-        return len(super().get_neighboring_agents(state_id=state_id, **kwargs))
-
-    def get_neighboring_agents(self, state_id=None, **kwargs):
-        return self.get_agents(limit_neighbors=True, state_id=state_id, **kwargs)
-
-    def get_agents(self, agents=None, limit_neighbors=False, **kwargs):
-        if limit_neighbors:
-            agents = super().get_agents(limit_neighbors=limit_neighbors)
-        else:
-            agents = self.env.get_agents(agents)
-        return select(agents, **kwargs)
+        if not self.alive:
+            raise DeadAgent(self.unique_id)
+        return super().step() or time.Delta(self.interval)
 
     def log(self, message, *args, level=logging.INFO, **kwargs):
+        if not self.logger.isEnabledFor(level):
+            return
         message = message + " ".join(str(i) for i in args)
-        message = "\t{:10}@{:>5}:\t{}".format(self.name, self.now, message)
+        message = " @{:>3}: {}".format(self.now, message)
         for k, v in kwargs:
             message += " {k}={v} ".format(k, v)
         extra = {}
         extra['now'] = self.now
-        extra['id'] = self.id
+        extra['unique_id'] = self.unique_id
+        extra['agent_name'] = self.name
         return self.logger.log(level, message, extra=extra)
 
     def debug(self, *args, **kwargs):
@@ -172,44 +171,55 @@ class BaseAgent(nxsim.BaseAgent):
     def info(self, *args, **kwargs):
         return self.log(*args, level=logging.INFO, **kwargs)
 
-    def __getstate__(self):
-        '''
-        Serializing an agent will lose all its running information (you cannot
-        serialize an iterator), but it keeps the state and link to the environment,
-        so it can be used for inspection and dumping to a file
-        '''
-        state = {}
-        state['id'] = self.id
-        state['environment'] = self.env
-        state['_state'] = self._state
-        return state
-
-    def __setstate__(self, state):
-        '''
-        Get back a serialized agent and try to re-compose it
-        '''
-        self.id = state['id']
-        self._state = state['_state']
-        self.env = state['environment']
-
-    def add_edge(self, node1, node2, **attrs):
-        node1 = as_node(node1)
-        node2 = as_node(node2)
-
-        for n in [node1, node2]:
-            if n not in self.global_topology.nodes(data=False):
-                raise ValueError('"{}" not in the graph'.format(n))
-        return self.global_topology.add_edge(node1, node2, **attrs)
-
-    def subgraph(self, center=True, **kwargs):
-        include = [self] if center else []
-        return self.global_topology.subgraph(n.id for n in self.get_agents(**kwargs)+include)
-
 
 class NetworkAgent(BaseAgent):
 
-    def add_edge(self, other, **kwargs):
-        return super(NetworkAgent, self).add_edge(node1=self.id, node2=other, **kwargs)
+    @property
+    def topology(self):
+        return self.model.G
+
+    @property
+    def G(self):
+        return self.model.G
+
+    def count_agents(self, **kwargs):
+        return len(list(self.get_agents(**kwargs)))
+
+    def count_neighboring_agents(self, state_id=None, **kwargs):
+        return len(self.get_neighboring_agents(state_id=state_id, **kwargs))
+
+    def get_neighboring_agents(self, state_id=None, **kwargs):
+        return self.get_agents(limit_neighbors=True, state_id=state_id, **kwargs)
+
+    def get_agents(self, *args, limit=None, **kwargs):
+        it = self.iter_agents(*args, **kwargs)
+        if limit is not None:
+            it = islice(it, limit)
+        return list(it)
+
+    def iter_agents(self, agents=None, limit_neighbors=False, **kwargs):
+        if limit_neighbors:
+            agents = self.topology.neighbors(self.unique_id)
+
+        agents = self.model.get_agents(agents)
+        return select(agents, **kwargs)
+
+    def subgraph(self, center=True, **kwargs):
+        include = [self] if center else []
+        return self.topology.subgraph(n.unique_id for n in list(self.get_agents(**kwargs))+include)
+
+    def remove_node(self, unique_id):
+        self.topology.remove_node(unique_id)
+
+    def add_edge(self, other, edge_attr_dict=None, *edge_attrs):
+        # return super(NetworkAgent, self).add_edge(node1=self.id, node2=other, **kwargs)
+        if self.unique_id not in self.topology.nodes(data=False):
+            raise ValueError('{} not in list of existing agents in the network'.format(self.unique_id))
+        if other.unique_id not in self.topology.nodes(data=False):
+            raise ValueError('{} not in list of existing agents in the network'.format(other))
+
+        self.topology.add_edge(self.unique_id, other.unique_id, edge_attr_dict=edge_attr_dict, *edge_attrs)
+
 
     def ego_search(self, steps=1, center=False, node=None, **kwargs):
         '''Get a list of nodes in the ego network of *node* of radius *steps*'''
@@ -219,17 +229,17 @@ class NetworkAgent(BaseAgent):
 
     def degree(self, node, force=False):
         node = as_node(node)
-        if force or (not hasattr(self.env, '_degree')) or getattr(self.env, '_last_step', 0) < self.now:
-            self.env._degree = nx.degree_centrality(self.global_topology)
-            self.env._last_step = self.now
-        return self.env._degree[node]
+        if force or (not hasattr(self.model, '_degree')) or getattr(self.model, '_last_step', 0) < self.now:
+            self.model._degree = nx.degree_centrality(self.topology)
+            self.model._last_step = self.now
+        return self.model._degree[node]
 
     def betweenness(self, node, force=False):
         node = as_node(node)
-        if force or (not hasattr(self.env, '_betweenness')) or getattr(self.env, '_last_step', 0) < self.now:
-            self.env._betweenness = nx.betweenness_centrality(self.global_topology)
-            self.env._last_step = self.now
-        return self.env._betweenness[node]
+        if force or (not hasattr(self.model, '_betweenness')) or getattr(self.model, '_last_step', 0) < self.now:
+            self.model._betweenness = nx.betweenness_centrality(self.topology)
+            self.model._last_step = self.now
+        return self.model._betweenness[node]
 
 
 def state(name=None):
@@ -271,7 +281,7 @@ def default_state(func):
 
 class MetaFSM(type):
     def __init__(cls, name, bases, nmspc):
-        super(MetaFSM, cls).__init__(name, bases, nmspc)
+        super().__init__(name, bases, nmspc)
         states = {}
         # Re-use states from inherited classes
         default_state = None
@@ -292,31 +302,35 @@ class MetaFSM(type):
         cls.states = states
 
 
-class FSM(BaseAgent, metaclass=MetaFSM):
+class FSM(NetworkAgent, metaclass=MetaFSM):
     def __init__(self, *args, **kwargs):
         super(FSM, self).__init__(*args, **kwargs)
-        if 'id' not in self.state:
+        if not hasattr(self, 'state_id'):
             if not self.default_state:
-                raise ValueError('No default state specified for {}'.format(self.id))
-            self['id'] = self.default_state.id
+                raise ValueError('No default state specified for {}'.format(self.unique_id))
+            self.state_id = self.default_state.id
+
+        self.set_state(self.state_id)
 
     def step(self):
-        if 'id' in self.state:
-            next_state = self['id']
-        elif self.default_state:
-            next_state = self.default_state.id
-        else:
-            raise Exception('{} has no valid state id or default state'.format(self))
-        if next_state not in self.states:
-            raise Exception('{} is not a valid id for {}'.format(next_state, self))
-        return self.states[next_state](self)
+        self.debug(f'Agent {self.unique_id} @ state {self.state_id}')
+        interval = super().step()
+        if 'id' not in self.state:
+            if self.default_state:
+                self.set_state(self.default_state.id)
+            else:
+                raise Exception('{} has no valid state id or default state'.format(self))
+        interval = self.states[self.state_id](self) or interval
+        if not self.alive:
+            return time.NEVER
+        return interval
 
     def set_state(self, state):
         if hasattr(state, 'id'):
             state = state.id
         if state not in self.states:
             raise ValueError('{} is not a valid state'.format(state))
-        self['id'] = state
+        self.state_id = state
         return state
 
 
@@ -335,9 +349,6 @@ def prob(prob=1):
     return r < prob
 
 
-STATIC_THRESHOLD = (-1, -1)
-
-
 def calculate_distribution(network_agents=None,
                            agent_type=None):
     '''
@@ -365,20 +376,23 @@ def calculate_distribution(network_agents=None,
     'agent_type_1'.
     '''
     if network_agents:
-        network_agents = deepcopy(network_agents)
+        network_agents = [deepcopy(agent) for agent in network_agents if not hasattr(agent, 'id')]
     elif agent_type:
         network_agents = [{'agent_type': agent_type}]
     else:
         raise ValueError('Specify a distribution or a default agent type')
 
+    # Fix missing weights and incompatible types
+    for x in network_agents:
+        x['weight'] = float(x.get('weight', 1))
+
     # Calculate the thresholds
-    total = sum(x.get('weight', 1) for x in network_agents)
+    total = sum(x['weight'] for x in network_agents)
     acc = 0
     for v in network_agents:
         if 'ids' in v:
-            v['threshold'] = STATIC_THRESHOLD
             continue
-        upper = acc + (v.get('weight', 1)/total)
+        upper = acc + (v['weight']/total)
         v['threshold'] = [acc, upper]
         acc = upper
     return network_agents
@@ -391,7 +405,7 @@ def serialize_type(agent_type, known_modules=[], **kwargs):
     return serialization.serialize(agent_type, known_modules=known_modules, **kwargs)[1] # Get the name of the class
 
 
-def serialize_distribution(network_agents, known_modules=[]):
+def serialize_definition(network_agents, known_modules=[]):
     '''
     When serializing an agent distribution, remove the thresholds, in order
     to avoid cluttering the YAML definition file.
@@ -413,7 +427,7 @@ def deserialize_type(agent_type, known_modules=[]):
     return agent_type
 
 
-def deserialize_distribution(ind, **kwargs):
+def deserialize_definition(ind, **kwargs):
     d = deepcopy(ind)
     for v in d:
         v['agent_type'] = deserialize_type(v['agent_type'], **kwargs)
@@ -425,7 +439,7 @@ def _validate_states(states, topology):
     states = states or []
     if isinstance(states, dict):
         for x in states:
-            assert x in topology.node
+            assert x in topology.nodes
     else:
         assert len(states) <= len(topology)
     return states
@@ -434,44 +448,85 @@ def _validate_states(states, topology):
 def _convert_agent_types(ind, to_string=False, **kwargs):
     '''Convenience method to allow specifying agents by class or class name.'''
     if to_string:
-        return serialize_distribution(ind, **kwargs)
-    return deserialize_distribution(ind, **kwargs)
+        return serialize_definition(ind, **kwargs)
+    return deserialize_definition(ind, **kwargs)
 
 
-def _agent_from_distribution(distribution, value=-1, agent_id=None):
+def _agent_from_definition(definition, value=-1, unique_id=None):
     """Used in the initialization of agents given an agent distribution."""
     if value < 0:
         value = random.random()
-    for d in sorted(distribution, key=lambda x: x['threshold']):
-        threshold = d['threshold']
+    for d in sorted(definition, key=lambda x: x.get('threshold')):
+        threshold = d.get('threshold', (-1, -1))
         # Check if the definition matches by id (first) or by threshold
-        if not ((agent_id is not None and threshold == STATIC_THRESHOLD and agent_id in d['ids']) or \
-                (value >= threshold[0] and value < threshold[1])):
-            continue
-        state = {}
-        if 'state' in d:
-            state = deepcopy(d['state'])
-        return d['agent_type'], state
+        if (unique_id is not None and unique_id in d.get('ids', [])) or \
+           (value >= threshold[0] and value < threshold[1]):
+            state = {}
+            if 'state' in d:
+                state = deepcopy(d['state'])
+            return d['agent_type'], state
 
-    raise Exception('Distribution for value {} not found in: {}'.format(value, distribution))
+    raise Exception('Definition for value {} not found in: {}'.format(value, definition))
 
 
-class Geo(NetworkAgent):
-    '''In this type of network, nodes have a "pos" attribute.'''
+def _definition_to_dict(definition, size=None, default_state=None):
+    state = default_state or {}
+    agents = {}
+    remaining = {}
+    if size:
+        for ix in range(size):
+            remaining[ix] = copy(state)
+    else:
+        remaining = defaultdict(lambda x: copy(state))
 
-    def geo_search(self, radius, node=None, center=False, **kwargs):
-        '''Get a list of nodes whose coordinates are closer than *radius* to *node*.'''
-        node = as_node(node if node is not None else self)
+    distro = sorted([item for item in definition if 'weight' in item])
 
-        G = self.subgraph(**kwargs)
+    ix = 0
 
-        pos = nx.get_node_attributes(G, 'pos')
-        if not pos:
-            return []
-        nodes, coords = list(zip(*pos.items()))
-        kdtree = KDTree(coords)  # Cannot provide generator.
-        indices = kdtree.query_ball_point(pos[node], radius)
-        return [nodes[i] for i in indices if center or (nodes[i] != node)]
+    def init_agent(item, id=ix):
+        while id in agents:
+            id += 1
+
+        agent = remaining[id]
+        agent['state'].update(copy(item.get('state', {})))
+        agents[id] = agent
+        del remaining[id]
+        return agent
+
+    for item in definition:
+        if 'ids' in item:
+            ids = item['ids']
+            del item['ids']
+            for id in ids:
+                agent = init_agent(item, id)
+
+    for item in definition:
+        if 'number' in item:
+            times = item['number']
+            del item['number']
+            for times in range(times):
+                if size:
+                    ix = random.choice(remaining.keys())
+                    agent = init_agent(item, id)
+                else:
+                    agent = init_agent(item)
+    if not size:
+        return agents
+
+    if len(remaining) < 0:
+        raise Exception('Invalid definition. Too many agents to add')
+
+
+    total_weight = float(sum(s['weight'] for s in distro))
+    unit = size / total_weight
+
+    for item in distro:
+        times = unit * item['weight']
+        del item['weight']
+        for times in range(times):
+            ix = random.choice(remaining.keys())
+            agent = init_agent(item, id)
+    return agents
 
 
 def select(agents, state_id=None, agent_type=None, ignore=None, iterator=False, **kwargs):
@@ -484,25 +539,22 @@ def select(agents, state_id=None, agent_type=None, ignore=None, iterator=False,
         except TypeError:
             agent_type = tuple([agent_type])
 
-    def matches_all(agent):
-        if state_id is not None:
-            if agent.state.get('id', None) not in state_id:
-                return False
-        if agent_type is not None:
-            if not isinstance(agent, agent_type):
-                return False
-        state = agent.state
-        for k, v in kwargs.items():
-            if state.get(k, None) != v:
-                return False
-        return True
+    f = agents
 
-    f = filter(matches_all, agents)
     if ignore:
         f = filter(lambda x: x not in ignore, f)
+
+    if state_id is not None:
+        f = filter(lambda agent: agent.get('state_id', None) in state_id, f)
+
+    if agent_type is not None:
+        f = filter(lambda agent: isinstance(agent, agent_type), f)
+    for k, v in kwargs.items():
+        f = filter(lambda agent: agent.state.get(k, None) == v, f)
+
     if iterator:
         return f
-    return list(f)
+    return f
 
 
 from .BassModel import *
@@ -512,3 +564,10 @@ from .ModelM2 import *
 from .SentimentCorrelationModel import *
 from .SISaModel import *
 from .CounterModel import *
+
+try:
+    import scipy
+    from .Geo import Geo
+except ImportError:
+    import sys
+    print('Could not load the Geo Agent, scipy is not installed', file=sys.stderr)

soil/analysis.py

@@ -4,7 +4,8 @@ import glob
 import yaml
 from os.path import join
 
-from . import serialization, history
+from . import serialization
+from tsih import History
 
 
 def read_data(*args, group=False, **kwargs):
@@ -20,7 +21,7 @@ def _read_data(pattern, *args, from_csv=False, process_args=None, **kwargs):
         process_args = {}
     for folder in glob.glob(pattern):
         config_file = glob.glob(join(folder, '*.yml'))[0]
-        config = yaml.load(open(config_file))
+        config = yaml.load(open(config_file), Loader=yaml.SafeLoader)
         df = None
         if from_csv:
             for trial_data in sorted(glob.glob(join(folder,
@@ -28,13 +29,13 @@ def _read_data(pattern, *args, from_csv=False, process_args=None, **kwargs):
                 df = read_csv(trial_data, **kwargs)
                 yield config_file, df, config
         else:
-            for trial_data in sorted(glob.glob(join(folder, '*.db.sqlite'))):
+            for trial_data in sorted(glob.glob(join(folder, '*.sqlite'))):
                 df = read_sql(trial_data, **kwargs)
                 yield config_file, df, config
 
 
 def read_sql(db, *args, **kwargs):
-    h = history.History(db_path=db, backup=False)
+    h = History(db_path=db, backup=False, readonly=True)
     df = h.read_sql(*args, **kwargs)
     return df
 
@@ -61,7 +62,12 @@ def convert_row(row):
 
 
 def convert_types_slow(df):
-    '''This is a slow operation.'''
+    '''
+    Go over every column in a dataframe and convert it to the type determined by the `get_types`
+    function.
+
+    This is a slow operation.
+    '''
     dtypes = get_types(df)
     for k, v in dtypes.items():
         t = df[df['key']==k]
@@ -69,6 +75,13 @@ def convert_types_slow(df):
     df = df.apply(convert_row, axis=1)
     return df
 
+
+def split_processed(df):
+    env = df.loc[:, df.columns.get_level_values(1).isin(['env', 'stats'])]
+    agents = df.loc[:, ~df.columns.get_level_values(1).isin(['env', 'stats'])]
+    return env, agents
+
+
 def split_df(df):
     '''
     Split a dataframe in two dataframes: one with the history of agents,
@@ -95,8 +108,11 @@ def process(df, **kwargs):
 
 
 def get_types(df):
+    '''
+    Get the value type for every key stored in a raw history dataframe.
+    '''
     dtypes = df.groupby(by=['key'])['value_type'].unique()
-    return {k:v[0] for k,v in dtypes.iteritems()}
+    return {k:v[0] for k,v in dtypes.items()}
 
 
 def process_one(df, *keys, columns=['key', 'agent_id'], values='value',
@@ -119,24 +135,45 @@ def process_one(df, *keys, columns=['key', 'agent_id'], values='value',
 
 
 def get_count(df, *keys):
+    '''
+    For every t_step and key, get the value count.
+
+    The result is a dataframe with `t_step` as index, an a multiindex column based on `key` and the values found for each `key`.
+    '''
     if keys:
         df = df[list(keys)]
+        df.columns = df.columns.remove_unused_levels()
     counts = pd.DataFrame()
     for key in df.columns.levels[0]:
         g = df[[key]].apply(pd.Series.value_counts, axis=1).fillna(0)
-        for value, series in g.iteritems():
+        for value, series in g.items():
             counts[key, value] = series
     counts.columns = pd.MultiIndex.from_tuples(counts.columns)
     return counts
 
 
+def get_majority(df, *keys):
+    '''
+    For every t_step and key, get the value of the majority of agents
+
+    The result is a dataframe with `t_step` as index, and columns based on `key`.
+    '''
+    df = get_count(df, *keys)
+    return df.stack(level=0).idxmax(axis=1).unstack()
+
+
 def get_value(df, *keys, aggfunc='sum'):
+    '''
+    For every t_step and key, get the value of *numeric columns*, aggregated using a specific function.
+    '''
     if keys:
         df = df[list(keys)]
-    return df.groupby(axis=1, level=0).agg(aggfunc, axis=1)
+        df.columns = df.columns.remove_unused_levels()
+    df = df.select_dtypes('number')
+    return df.groupby(level='key', axis=1).agg(aggfunc)
 
 
-def plot_all(*args, **kwargs):
+def plot_all(*args, plot_args={}, **kwargs):
     '''
     Read all the trial data and plot the result of applying a function on them.
     '''
@@ -144,14 +181,17 @@ def plot_all(*args, **kwargs):
     ps = []
     for line in dfs:
         f, df, config = line
-        df.plot(title=config['name'])
+        if len(df) < 1:
+            continue
+        df.plot(title=config['name'], **plot_args)
         ps.append(df)
     return ps
 
 def do_all(pattern, func, *keys, include_env=False, **kwargs):
     for config_file, df, config in read_data(pattern, keys=keys):
+        if len(df) < 1:
+            continue
         p = func(df, *keys, **kwargs)
-        p.plot(title=config['name'])
         yield config_file, p, config
 
 

soil/datacollection.py

@@ -0,0 +1,26 @@
+from mesa import DataCollector as MDC
+
+class SoilDataCollector(MDC):
+
+
+    def __init__(self, environment, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Populate model and env reporters so they have a key per 
+        # So they can be shown in the web interface
+        self.environment = environment
+
+
+    @property
+    def model_vars(self):
+        pass
+
+    @model_vars.setter
+    def model_vars(self, value):
+        pass
+
+    @property
+    def agent_reporters(self):
+        self.model._history._
+
+        pass
+

soil/environment.py

@@ -1,29 +1,32 @@
 import os
 import sqlite3
-import time
 import csv
+import math
 import random
-import simpy
 import yaml
 import tempfile
+import logging
 import pandas as pd
+from time import time as current_time
 from copy import deepcopy
-from collections import Counter
 from networkx.readwrite import json_graph
 
 import networkx as nx
-import nxsim
 
-from . import serialization, agents, analysis, history, utils
+from tsih import History, Record, Key, NoHistory
+
+from mesa import Model
+
+from . import serialization, agents, analysis, utils, time
 
 # These properties will be copied when pickling/unpickling the environment
 _CONFIG_PROPS = [ 'name',
-                 'states',
-                 'default_state',
-                 'interval',
+                  'states',
+                  'default_state',
+                  'interval',
                  ]
 
-class Environment(nxsim.NetworkEnvironment):
+class Environment(Model):
     """
     The environment is key in a simulation. It contains the network topology,
     a reference to network and environment agents, as well as the environment
@@ -40,27 +43,72 @@ class Environment(nxsim.NetworkEnvironment):
                  states=None,
                  default_state=None,
                  interval=1,
+                 network_params=None,
                  seed=None,
                  topology=None,
-                 *args, **kwargs):
+                 schedule=None,
+                 initial_time=0,
+                 environment_params=None,
+                 history=True,
+                 dir_path=None,
+                 **kwargs):
+
+
+        super().__init__()
+
+        self.schedule = schedule
+        if schedule is None:
+            self.schedule = time.TimedActivation()
+
         self.name = name or 'UnnamedEnvironment'
+        seed = seed or current_time()
+        random.seed(seed)
         if isinstance(states, list):
             states = dict(enumerate(states))
         self.states = deepcopy(states) if states else {}
         self.default_state = deepcopy(default_state) or {}
+
+        if topology is None:
+            network_params = network_params or {}
+            topology = serialization.load_network(network_params,
+                                                  dir_path=dir_path)
         if not topology:
             topology = nx.Graph()
-        super().__init__(*args, topology=topology, **kwargs)
+        self.G = nx.Graph(topology) 
+
+
+        self.environment_params = environment_params or {}
+        self.environment_params.update(kwargs)
+
         self._env_agents = {}
         self.interval = interval
-        self._history = history.History(name=self.name,
-                                        backup=True)
-        # Add environment agents first, so their events get
-        # executed before network agents
-        self.environment_agents = environment_agents or []
-        self.network_agents = network_agents or []
-        self['SEED'] = seed or time.time()
-        random.seed(self['SEED'])
+        if history:
+            history = History
+        else:
+            history = NoHistory
+        self._history = history(name=self.name,
+                                backup=True)
+        self['SEED'] = seed
+
+        if network_agents:
+            distro = agents.calculate_distribution(network_agents)
+            self.network_agents = agents._convert_agent_types(distro)
+        else:
+            self.network_agents = []
+
+        environment_agents = environment_agents or []
+        if environment_agents:
+            distro = agents.calculate_distribution(environment_agents)
+            environment_agents = agents._convert_agent_types(distro)
+        self.environment_agents = environment_agents
+
+        self.logger = utils.logger.getChild(self.name)
+
+    @property
+    def now(self):
+        if self.schedule:
+            return self.schedule.time
+        raise Exception('The environment has not been scheduled, so it has no sense of time')
 
     @property
     def agents(self):
@@ -74,20 +122,15 @@ class Environment(nxsim.NetworkEnvironment):
 
     @environment_agents.setter
     def environment_agents(self, environment_agents):
-        # Set up environmental agent
-        self._env_agents = {}
-        for item in environment_agents:
-            kwargs = deepcopy(item)
-            atype = kwargs.pop('agent_type')
-            kwargs['agent_id'] = kwargs.get('agent_id', atype.__name__)
-            kwargs['state'] = kwargs.get('state', {})
-            a = atype(environment=self, **kwargs)
-            self._env_agents[a.id] = a
+        self._environment_agents = environment_agents
+
+        for (ix, agent) in enumerate(self._environment_agents):
+            self.init_agent(len(self.G) + ix, agent_definitions=environment_agents, with_node=False)
 
     @property
     def network_agents(self):
         for i in self.G.nodes():
-            node = self.G.node[i]
+            node = self.G.nodes[i]
             if 'agent' in node:
                 yield node['agent']
 
@@ -95,44 +138,55 @@ class Environment(nxsim.NetworkEnvironment):
     def network_agents(self, network_agents):
         self._network_agents = network_agents
         for ix in self.G.nodes():
-            self.init_agent(ix, agent_distribution=network_agents)
+            self.init_agent(ix, agent_definitions=network_agents)
 
-    def init_agent(self, agent_id, agent_distribution):
-        node = self.G.nodes[agent_id]
+    def init_agent(self, agent_id, agent_definitions, with_node=True):
         init = False
-        state = dict(node)
+
+        state = {}
+        if with_node:
+            node = self.G.nodes[agent_id]
+            state = dict(node)
+        state.update(self.states.get(agent_id, {}))
 
         agent_type = None
-        if 'agent_type' in self.states.get(agent_id, {}):
-            agent_type = self.states[agent_id]['agent_type']
-        elif 'agent_type' in node:
+        if 'agent_type' in state:
+            agent_type = state['agent_type']
+        elif with_node and 'agent_type' in node:
             agent_type = node['agent_type']
         elif 'agent_type' in self.default_state:
             agent_type = self.default_state['agent_type']
 
         if agent_type:
             agent_type = agents.deserialize_type(agent_type)
-        elif agent_distribution:
-            agent_type, state = agents._agent_from_distribution(agent_distribution, agent_id=agent_id)
+        elif agent_definitions:
+            agent_type, state = agents._agent_from_definition(agent_definitions, unique_id=agent_id)
         else:
-            serialization.logger.debug('Skipping node {}'.format(agent_id))
+            serialization.logger.debug('Skipping agent {}'.format(agent_id))
             return
-        return self.set_agent(agent_id, agent_type, state)
+        return self.set_agent(agent_id, agent_type, state, with_node=with_node)
 
-    def set_agent(self, agent_id, agent_type, state=None):
-        node = self.G.nodes[agent_id]
+    def set_agent(self, agent_id, agent_type, state=None, with_node=True):
         defstate = deepcopy(self.default_state) or {}
         defstate.update(self.states.get(agent_id, {}))
-        defstate.update(node.get('state', {}))
+        if with_node:
+            node = self.G.nodes[agent_id]
+            defstate.update(node.get('state', {}))
         if state:
             defstate.update(state)
         a = None
         if agent_type:
             state = defstate
-            a = agent_type(environment=self,
-                           agent_id=agent_id,
-                           state=state)
-        node['agent'] = a
+            a = agent_type(model=self,
+                           unique_id=agent_id
+            )
+
+        for (k, v) in state.items():
+            setattr(a, k, v)
+
+        if with_node:
+            node['agent'] = a
+        self.schedule.add(a)
         return a
 
     def add_node(self, agent_type, state=None):
@@ -150,34 +204,35 @@ class Environment(nxsim.NetworkEnvironment):
         start = start or self.now
         return self.G.add_edge(agent1, agent2, **attrs)
 
-    def run(self, *args, **kwargs):
+    def log(self, message, *args, level=logging.INFO, **kwargs):
+        if not self.logger.isEnabledFor(level):
+            return
+        message = message + " ".join(str(i) for i in args)
+        message = " @{:>3}: {}".format(self.now, message)
+        for k, v in kwargs:
+            message += " {k}={v} ".format(k, v)
+        extra = {}
+        extra['now'] = self.now
+        extra['unique_id'] = self.name
+        return self.logger.log(level, message, extra=extra)
+
+    def step(self):
+        super().step()
+        self.schedule.step()
+
+    def run(self, until, *args, **kwargs):
         self._save_state()
-        self.log_stats()
-        super().run(*args, **kwargs)
+
+        while self.schedule.next_time < until:
+            self.step()
+            utils.logger.debug(f'Simulation step {self.schedule.time}/{until}. Next: {self.schedule.next_time}')
+        self.schedule.time = until
         self._history.flush_cache()
-        self.log_stats()
 
     def _save_state(self, now=None):
         serialization.logger.debug('Saving state @{}'.format(self.now))
         self._history.save_records(self.state_to_tuples(now=now))
 
-    def save_state(self):
-        '''
-        :DEPRECATED:
-        Periodically save the state of the environment and the agents.
-        '''
-        self._save_state()
-        while self.peek() != simpy.core.Infinity:
-            delay = max(self.peek() - self.now, self.interval)
-            serialization.logger.debug('Step: {}'.format(self.now))
-            ev = self.event()
-            ev._ok = True
-            # Schedule the event with minimum priority so
-            # that it executes before all agents
-            self.schedule(ev, -999, delay)
-            yield ev
-            self._save_state()
-
     def __getitem__(self, key):
         if isinstance(key, tuple):
             self._history.flush_cache()
@@ -187,12 +242,12 @@ class Environment(nxsim.NetworkEnvironment):
 
     def __setitem__(self, key, value):
         if isinstance(key, tuple):
-            k = history.Key(*key)
+            k = Key(*key)
             self._history.save_record(*k,
                                       value=value)
             return
         self.environment_params[key] = value
-        self._history.save_record(agent_id='env',
+        self._history.save_record(dict_id='env',
                                   t_step=self.now,
                                   key=key,
                                   value=value)
@@ -212,12 +267,12 @@ class Environment(nxsim.NetworkEnvironment):
         return self[key] if key in self else default
 
     def get_agent(self, agent_id):
-        return self.G.node[agent_id]['agent']
+        return self.G.nodes[agent_id]['agent']
 
     def get_agents(self, nodes=None):
         if nodes is None:
-            return list(self.agents)
-        return [self.G.node[i]['agent'] for i in nodes]
+            return self.agents
+        return (self.G.nodes[i]['agent'] for i in nodes)
 
     def dump_csv(self, f):
         with utils.open_or_reuse(f, 'w') as f:
@@ -231,9 +286,9 @@ class Environment(nxsim.NetworkEnvironment):
         # Workaround for geometric models
         # See soil/soil#4
         for node in G.nodes():
-            if 'pos' in G.node[node]:
-                G.node[node]['viz'] = {"position": {"x": G.node[node]['pos'][0], "y": G.node[node]['pos'][1], "z": 0.0}}
-                del (G.node[node]['pos'])
+            if 'pos' in G.nodes[node]:
+                G.nodes[node]['viz'] = {"position": {"x": G.nodes[node]['pos'][0], "y": G.nodes[node]['pos'][1], "z": 0.0}}
+                del (G.nodes[node]['pos'])
 
         nx.write_gexf(G, f, version="1.2draft")
 
@@ -257,16 +312,16 @@ class Environment(nxsim.NetworkEnvironment):
         if now is None:
             now = self.now
         for k, v in self.environment_params.items():
-            yield history.Record(agent_id='env',
-                                 t_step=now,
-                                 key=k,
-                                 value=v)
+            yield Record(dict_id='env',
+                         t_step=now,
+                         key=k,
+                         value=v)
         for agent in self.agents:
             for k, v in agent.state.items():
-                yield history.Record(agent_id=agent.id,
-                                     t_step=now,
-                                     key=k,
-                                     value=v)
+                yield Record(dict_id=agent.id,
+                             t_step=now,
+                             key=k,
+                             value=v)
 
     def history_to_tuples(self):
         return self._history.to_tuples()
@@ -317,25 +372,6 @@ class Environment(nxsim.NetworkEnvironment):
 
         return G
 
-    def stats(self):
-        stats = {}
-        stats['network'] = {}
-        stats['network']['n_nodes'] = self.G.number_of_nodes()
-        stats['network']['n_edges'] = self.G.number_of_edges()
-        c = Counter()
-        c.update(a.__class__.__name__ for a in self.network_agents)
-        stats['agents'] = {}
-        stats['agents']['model_count'] = dict(c)
-        c2 = Counter()
-        c2.update(a['id'] for a in self.network_agents)
-        stats['agents']['state_count'] = dict(c2)
-        stats['params'] = self.environment_params
-        return stats
-
-    def log_stats(self):
-        stats = self.stats()
-        serialization.logger.info('Environment stats: \n{}'.format(yaml.dump(stats, default_flow_style=False)))
-    
     def __getstate__(self):
         state = {}
         for prop in _CONFIG_PROPS:
@@ -343,6 +379,7 @@ class Environment(nxsim.NetworkEnvironment):
         state['G'] = json_graph.node_link_data(self.G)
         state['environment_agents'] = self._env_agents
         state['history'] = self._history
+        state['schedule'] = self.schedule
         return state
 
     def __setstate__(self, state):
@@ -351,6 +388,9 @@ class Environment(nxsim.NetworkEnvironment):
         self._env_agents = state['environment_agents']
         self.G = json_graph.node_link_graph(state['G'])
         self._history = state['history']
+        # self._env = None
+        self.schedule = state['schedule']
+        self._queue = []
 
 
 SoilEnvironment = Environment

soil/exporters.py

@@ -1,10 +1,11 @@
 import os
+import csv as csvlib
 import time
 from io import BytesIO
 
 import matplotlib.pyplot as plt
 import networkx as nx
-import pandas as pd
+
 
 from .serialization import deserialize
 from .utils import open_or_reuse, logger, timer
@@ -13,15 +14,6 @@ from .utils import open_or_reuse, logger, timer
 from . import utils
 
 
-def for_sim(simulation, names, *args, **kwargs):
-    '''Return the set of exporters for a simulation, given the exporter names'''
-    exporters = []
-    for name in names:
-        mod = deserialize(name, known_modules=['soil.exporters'])
-        exporters.append(mod(simulation, *args, **kwargs))
-    return exporters
-
-
 class DryRunner(BytesIO):
     def __init__(self, fname, *args, copy_to=None, **kwargs):
         super().__init__(*args, **kwargs)
@@ -37,8 +29,12 @@ class DryRunner(BytesIO):
             super().write(bytes(txt, 'utf-8'))
 
     def close(self):
-        logger.info('**Not** written to {} (dry run mode):\n\n{}\n\n'.format(self.__fname,
-                                                                       self.getvalue().decode()))
+        content = '(binary data not shown)'
+        try:
+            content = self.getvalue().decode()
+        except UnicodeDecodeError:
+            pass
+        logger.info('**Not** written to {} (dry run mode):\n\n{}\n\n'.format(self.__fname, content))
         super().close()
 
 
@@ -49,7 +45,7 @@ class Exporter:
     '''
 
     def __init__(self, simulation, outdir=None, dry_run=None, copy_to=None):
-        self.sim = simulation
+        self.simulation = simulation
         outdir = outdir or os.path.join(os.getcwd(), 'soil_output')
         self.outdir = os.path.join(outdir,
                                    simulation.group or '',
@@ -59,12 +55,15 @@ class Exporter:
 
     def start(self):
         '''Method to call when the simulation starts'''
+        pass
 
-    def end(self):
+    def end(self, stats):
         '''Method to call when the simulation ends'''
+        pass
 
-    def trial_end(self, env):
+    def trial(self, env, stats):
         '''Method to call when a trial ends'''
+        pass
 
     def output(self, f, mode='w', **kwargs):
         if self.dry_run:
@@ -84,35 +83,47 @@ class default(Exporter):
     def start(self):
         if not self.dry_run:
             logger.info('Dumping results to %s', self.outdir)
-            self.sim.dump_yaml(outdir=self.outdir)
+            self.simulation.dump_yaml(outdir=self.outdir)
         else:
             logger.info('NOT dumping results')
 
-    def trial_end(self, env):
+    def trial(self, env, stats):
         if not self.dry_run:
-            with timer('Dumping simulation {} trial {}'.format(self.sim.name,
+            with timer('Dumping simulation {} trial {}'.format(self.simulation.name,
                                                                env.name)):
                 with self.output('{}.sqlite'.format(env.name), mode='wb') as f:
                     env.dump_sqlite(f)
 
+    def end(self, stats):
+          with timer('Dumping simulation {}\'s stats'.format(self.simulation.name)):
+              with self.output('{}.sqlite'.format(self.simulation.name), mode='wb') as f:
+                  self.simulation.dump_sqlite(f)
+
+
 
 class csv(Exporter):
     '''Export the state of each environment (and its agents) in a separate CSV file'''
-    def trial_end(self, env):
-        with timer('[CSV] Dumping simulation {} trial {} @ dir {}'.format(self.sim.name,
+    def trial(self, env, stats):
+        with timer('[CSV] Dumping simulation {} trial {} @ dir {}'.format(self.simulation.name,
                                                                           env.name,
                                                                           self.outdir)):
             with self.output('{}.csv'.format(env.name)) as f:
                 env.dump_csv(f)
 
+            with self.output('{}.stats.csv'.format(env.name)) as f:
+                statwriter = csvlib.writer(f, delimiter='\t', quotechar='"', quoting=csvlib.QUOTE_ALL)
+
+                for stat in stats:
+                    statwriter.writerow(stat)
+
 
 class gexf(Exporter):
-    def trial_end(self, env):
+    def trial(self, env, stats):
         if self.dry_run:
             logger.info('Not dumping GEXF in dry_run mode')
             return
 
-        with timer('[GEXF] Dumping simulation {} trial {}'.format(self.sim.name,
+        with timer('[GEXF] Dumping simulation {} trial {}'.format(self.simulation.name,
                                                                   env.name)):
             with self.output('{}.gexf'.format(env.name), mode='wb') as f:
                 env.dump_gexf(f)
@@ -124,56 +135,24 @@ class dummy(Exporter):
         with self.output('dummy', 'w') as f:
             f.write('simulation started @ {}\n'.format(time.time()))
 
-    def trial_end(self, env):
+    def trial(self, env, stats):
         with self.output('dummy', 'w') as f:
             for i in env.history_to_tuples():
                 f.write(','.join(map(str, i)))
                 f.write('\n')
 
-    def end(self):
+    def sim(self, stats):
         with self.output('dummy', 'a') as f:
             f.write('simulation ended @ {}\n'.format(time.time()))
 
 
-class distribution(Exporter):
-    '''
-    Write the distribution of agent states at the end of each trial,
-    the mean value, and its deviation.
-    '''
-
-    def start(self):
-        self.means = []
-        self.counts = []
-
-    def trial_end(self, env):
-        df = env[None, None, None].df()
-        ix = df.index[-1]
-        attrs = df.columns.levels[0]
-        vc = {}
-        stats = {}
-        for a in attrs:
-            t = df.loc[(ix, a)]
-            try:
-                self.means.append(('mean', a, t.mean()))
-            except TypeError:
-                for name, count in t.value_counts().iteritems():
-                    self.counts.append(('count', a, name, count))
-
-    def end(self):
-        dfm = pd.DataFrame(self.means, columns=['metric', 'key', 'value'])
-        dfc = pd.DataFrame(self.counts, columns=['metric', 'key', 'value', 'count'])
-        dfm = dfm.groupby(by=['key']).agg(['mean', 'std', 'count', 'median', 'max', 'min'])
-        dfc = dfc.groupby(by=['key', 'value']).agg(['mean', 'std', 'count', 'median', 'max', 'min'])
-        with self.output('counts.csv') as f:
-            dfc.to_csv(f)
-        with self.output('metrics.csv') as f:
-            dfm.to_csv(f)
 
 class graphdrawing(Exporter):
 
-    def trial_end(self, env):
+    def trial(self, env, stats):
         # Outside effects
         f = plt.figure()
         nx.draw(env.G, node_size=10, width=0.2, pos=nx.spring_layout(env.G, scale=100), ax=f.add_subplot(111))
         with open('graph-{}.png'.format(env.name)) as f:
             f.savefig(f)
+

soil/history.py

@@ -1,315 +0,0 @@
-import time
-import os
-import pandas as pd
-import sqlite3
-import copy
-import logging
-import tempfile
-
-logger = logging.getLogger(__name__)
-
-from collections import UserDict, namedtuple
-
-from . import serialization
-from .utils import open_or_reuse
-
-
-class History:
-    """
-    Store and retrieve values from a sqlite database.
-    """
-
-    def __init__(self, name=None, db_path=None, backup=False):
-        self._db = None
-
-        if db_path is None:
-            if not name:
-                name = time.time()
-            _, db_path = tempfile.mkstemp(suffix='{}.sqlite'.format(name))
-
-        if backup and os.path.exists(db_path):
-            newname = db_path + '.backup{}.sqlite'.format(time.time())
-            os.rename(db_path, newname)
-
-        self.db_path = db_path
-
-        self.db = db_path
-
-        with self.db:
-            logger.debug('Creating database {}'.format(self.db_path))
-            self.db.execute('''CREATE TABLE IF NOT EXISTS history (agent_id text, t_step int, key text, value text text)''')
-            self.db.execute('''CREATE TABLE IF NOT EXISTS value_types (key text, value_type text)''')
-            self.db.execute('''CREATE UNIQUE INDEX IF NOT EXISTS idx_history ON history (agent_id, t_step, key);''')
-        self._dtypes = {}
-        self._tups = []
-
-    @property
-    def db(self):
-        try:
-            self._db.cursor()
-        except (sqlite3.ProgrammingError, AttributeError):
-            self.db = None  # Reset the database
-        return self._db
-
-    @db.setter
-    def db(self, db_path=None):
-        self._close()
-        db_path = db_path or self.db_path
-        if isinstance(db_path, str):
-            logger.debug('Connecting to database {}'.format(db_path))
-            self._db = sqlite3.connect(db_path)
-        else:
-            self._db = db_path
-
-    def _close(self):
-        if self._db is None:
-            return
-        self.flush_cache()
-        self._db.close()
-        self._db = None
-
-    @property
-    def dtypes(self):
-        self.read_types()
-        return {k:v[0] for k, v in self._dtypes.items()}
-
-    def save_tuples(self, tuples):
-        '''
-        Save a series of tuples, converting them to records if necessary
-        '''
-        self.save_records(Record(*tup) for tup in tuples)
-
-    def save_records(self, records):
-        '''
-        Save a collection of records
-        '''
-        for record in records:
-            if not isinstance(record, Record):
-                record = Record(*record)
-            self.save_record(*record)
-
-    def save_record(self, agent_id, t_step, key, value):
-        '''
-        Save a collection of records to the database.
-        Database writes are cached.
-        '''
-        value = self.convert(key, value)
-        self._tups.append(Record(agent_id=agent_id,
-                                 t_step=t_step,
-                                 key=key,
-                                 value=value))
-        if len(self._tups) > 100:
-            self.flush_cache()
-
-    def convert(self, key, value):
-        """Get the serialized value for a given key."""
-        if key not in self._dtypes:
-            self.read_types()
-            if key not in self._dtypes:
-                name = serialization.name(value)
-                serializer = serialization.serializer(name)
-                deserializer = serialization.deserializer(name)
-                self._dtypes[key] = (name, serializer, deserializer)
-                with self.db:
-                    self.db.execute("replace into value_types (key, value_type) values (?, ?)", (key, name))
-        return self._dtypes[key][1](value)
-
-    def recover(self, key, value):
-        """Get the deserialized value for a given key, and the serialized version."""
-        if key not in self._dtypes:
-            self.read_types()
-        if key not in self._dtypes:
-            raise ValueError("Unknown datatype for {} and {}".format(key, value))
-        return self._dtypes[key][2](value)
-
-    def flush_cache(self):
-        '''
-        Use a cache to save state changes to avoid opening a session for every change.
-        The cache will be flushed at the end of the simulation, and when history is accessed.
-        '''
-        logger.debug('Flushing cache {}'.format(self.db_path))
-        with self.db:
-            for rec in self._tups:
-                self.db.execute("replace into history(agent_id, t_step, key, value) values (?, ?, ?, ?)", (rec.agent_id, rec.t_step, rec.key, rec.value))
-        self._tups = list()
-
-    def to_tuples(self):
-        self.flush_cache()
-        with self.db:
-            res = self.db.execute("select agent_id, t_step, key, value from history ").fetchall()
-        for r in res:
-            agent_id, t_step, key, value = r
-            value = self.recover(key, value)
-            yield agent_id, t_step, key, value
-
-    def read_types(self):
-        with self.db:
-            res = self.db.execute("select key, value_type from value_types ").fetchall()
-        for k, v in res:
-            serializer = serialization.serializer(v)
-            deserializer = serialization.deserializer(v)
-            self._dtypes[k] = (v, serializer, deserializer)
-
-    def __getitem__(self, key):
-        self.flush_cache()
-        key = Key(*key)
-        agent_ids = [key.agent_id] if key.agent_id is not None else []
-        t_steps = [key.t_step] if key.t_step is not None else []
-        keys = [key.key] if key.key is not None else []
-
-        df = self.read_sql(agent_ids=agent_ids,
-                           t_steps=t_steps,
-                           keys=keys)
-        r = Records(df, filter=key, dtypes=self._dtypes)
-        if r.resolved:
-            return r.value()
-        return r
-
-    def read_sql(self, keys=None, agent_ids=None, t_steps=None, convert_types=False, limit=-1):
-
-        self.read_types()
-
-        def escape_and_join(v):
-            if v is None:
-                return
-            return ",".join(map(lambda x: "\'{}\'".format(x), v))
-
-        filters = [("key in ({})".format(escape_and_join(keys)), keys),
-                   ("agent_id in ({})".format(escape_and_join(agent_ids)), agent_ids)
-        ]
-        filters = list(k[0] for k in filters if k[1])
-
-        last_df = None
-        if t_steps:
-            # Look for the last value before the minimum step in the query
-            min_step = min(t_steps)
-            last_filters = ['t_step < {}'.format(min_step),]
-            last_filters = last_filters + filters
-            condition = ' and '.join(last_filters)
-
-            last_query = '''
-            select h1.*
-            from history h1
-            inner join (
-            select agent_id, key, max(t_step) as t_step
-            from history
-            where {condition}
-            group by agent_id, key
-            ) h2
-            on h1.agent_id = h2.agent_id  and
-               h1.key      = h2.key       and
-               h1.t_step   = h2.t_step
-            '''.format(condition=condition)
-            last_df = pd.read_sql_query(last_query, self.db)
-
-            filters.append("t_step >= '{}' and t_step <= '{}'".format(min_step, max(t_steps)))
-
-        condition = ''
-        if filters:
-            condition = 'where {} '.format(' and '.join(filters))
-        query = 'select * from history {} limit {}'.format(condition, limit)
-        df = pd.read_sql_query(query, self.db)
-        if last_df is not None:
-            df = pd.concat([df, last_df])
-
-        df_p = df.pivot_table(values='value', index=['t_step'],
-                              columns=['key', 'agent_id'],
-                              aggfunc='first')
-
-        for k, v in self._dtypes.items():
-            if k in df_p:
-                dtype, _, deserial = v
-                df_p[k] = df_p[k].fillna(method='ffill').astype(dtype)
-        if t_steps:
-            df_p = df_p.reindex(t_steps, method='ffill')
-        return df_p.ffill()
-
-    def __getstate__(self):
-        state = dict(**self.__dict__)
-        del state['_db']
-        del state['_dtypes']
-        return state
-
-    def __setstate__(self, state):
-        self.__dict__ = state
-        self._dtypes = {}
-        self._db = None
-
-    def dump(self, f):
-        self._close()
-        for line in open_or_reuse(self.db_path, 'rb'):
-            f.write(line)
-
-
-class Records():
-
-    def __init__(self, df, filter=None, dtypes=None):
-        if not filter:
-            filter = Key(agent_id=None,
-                         t_step=None,
-                         key=None)
-        self._df = df
-        self._filter = filter
-        self.dtypes = dtypes or {}
-        super().__init__()
-
-    def mask(self, tup):
-        res = ()
-        for i, k in zip(tup[:-1], self._filter):
-            if k is None:
-                res = res + (i,)
-        res = res + (tup[-1],)
-        return res
-
-    def filter(self, newKey):
-        f = list(self._filter)
-        for ix, i in enumerate(f):
-            if i is None:
-                f[ix] = newKey
-        self._filter = Key(*f)
-
-    @property
-    def resolved(self):
-        return sum(1 for i in self._filter if i is not None) == 3
-
-    def __iter__(self):
-        for column, series in self._df.iteritems():
-            key, agent_id = column
-            for t_step, value in series.iteritems():
-                r = Record(t_step=t_step,
-                           agent_id=agent_id,
-                           key=key,
-                           value=value)
-                yield self.mask(r)
-
-    def value(self):
-        if self.resolved:
-            f = self._filter
-            try:
-                i = self._df[f.key][str(f.agent_id)]
-                ix = i.index.get_loc(f.t_step, method='ffill')
-                return i.iloc[ix]
-            except KeyError as ex:
-                return self.dtypes[f.key][2]()
-        return list(self)
-
-    def df(self):
-        return self._df
-
-    def __getitem__(self, k):
-        n = copy.copy(self)
-        n.filter(k)
-        if n.resolved:
-            return n.value()
-        return n
-
-    def __len__(self):
-        return len(self._df)
-
-    def __str__(self):
-        if self.resolved:
-            return str(self.value())
-        return '<Records for [{}]>'.format(self._filter)
-
-Key = namedtuple('Key', ['agent_id', 't_step', 'key'])
-Record = namedtuple('Record', 'agent_id t_step key value')