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,21 +1,53 @@
-image: python:3.7
-
-steps:
-  - build
+stages:
   - test
+  - publish
+  - check_published
 
-build:
-  stage: build
+docker:
+  stage: publish
   image:
     name: gcr.io/kaniko-project/executor:debug
     entrypoint: [""]
+  tags:
+    - docker
   script:
     - echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > /kaniko/.docker/config.json
-    - /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --destination $CI_REGISTRY_IMAGE:$CI_COMMIT_TAG
+    # The skip-tls-verify flag is there because our registry certificate is self signed
+    - /kaniko/executor --context $CI_PROJECT_DIR --skip-tls-verify --dockerfile $CI_PROJECT_DIR/Dockerfile --destination $CI_REGISTRY_IMAGE:$CI_COMMIT_TAG
   only:
     - tags
 
-
 test:
+  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

@@ -0,0 +1,173 @@
+# Changelog
+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.
+## [0.14.3]
+### Fixed
+* Incompatibility with py3.3-3.6 due to ModuleNotFoundError and TypeError in DryRunner
+## [0.14.2]
+### Fixed
+* Output path for exporters is now soil_output
+### Changed 
+* CSV output to stdout in dry_run mode
+## [0.14.1]
+### Changed
+* Exporter names in lower case
+* Add default exporter in runs
+## [0.14.0]
+### Added
+* Loading configuration from template definitions in the yaml, in preparation for SALib support.
+The definition of the variables and their possible values (i.e., a problem in SALib terms), as well as a sampler function, can be provided.
+Soil uses this definition and the template to generate a set of configurations.
+* Simulation group names, to link related simulations. For now, they are only used to group all simulations in the same group under the same folder.
+* Exporters unify exporting/dumping results and other files to disk. If `dry_run` is set to `True`, exporters will write to stdout instead of a file (useful for testing/debugging).
+* Distribution exporter, to write statistics about values and value_counts in every simulation. The results are dumped to two CSV files.
+
+### Changed
+* `dir_path` is now the directory for resources (modules, files)
+* Environments and simulations do not export or write anything by default. That task is delegated to Exporters
+
+### Removed
+* The output dir for environments and simulations (see Exporters)
+* DrawingAgent, because it wrote to disk and was not being used. We provide a partial alternative in the form of the GraphDrawing exporter. A complete alternative will be provided once the network at each state can be accessed by exporters.
+
+## Fixed
+* Modules with custom agents/environments failed to load when they were run from outside the directory of the definition file. Modules are now loaded from the directory of the simulation file in addition to the working directory
+* Memory databases (in history) can now be shared between threads.
+* Testing all examples, not just subdirectories
+
+## [0.13.8]
+### Changed
+* Moved TerroristNetworkModel to examples
+### Added
+* `get_agents` and `count_agents` methods now accept lists as inputs. They can be used to retrieve agents from node ids
+* `subgraph` in BaseAgent
+* `agents.select` method, to filter out agents
+* `skip_test` property in yaml definitions, to force skipping some examples
+* `agents.Geo`, with a search function based on postition
+* `BaseAgent.ego_search` to get nodes from the ego network of a node
+* `BaseAgent.degree` and `BaseAgent.betweenness`
+### Fixed
+
+## [0.13.7]
+### Changed
+* History now defaults to not backing up! This makes it more intuitive to load the history for examination, at the expense of rewriting something. That should not happen because History is only created in the Environment, and that has `backup=True`.
+### Added
+* Agent names are assigned based on their agent types
+* Agent logging uses the agent name.
+* FSM agents can now return a timeout in addition to a new state. e.g. `return self.idle, self.env.timeout(2)` will execute the *different_state* in 2 *units of time* (`t_step=now+2`).
+* Example of using timeouts in FSM (custom_timeouts)
+* `network_agents` entries may include an `ids` entry. If set, it should be a list of node ids that should be assigned that agent type. This complements the previous behavior of setting agent type with `weights`.

MANIFEST.in

@@ -1,4 +1,7 @@
 include requirements.txt
 include test-requirements.txt
 include README.rst
-graft soil
+graft soil
+global-exclude __pycache__
+global-exclude soil_output
+global-exclude *.py[co]

Makefile

@@ -1,4 +1,7 @@
-test:
+quick-test:
 	docker-compose exec dev python -m pytest -s -v
 
-.PHONY: test
+test:
+	docker run -t -v $$PWD:/usr/src/app -w /usr/src/app python:3.7 python setup.py test
+
+.PHONY: test

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

@@ -1,12 +1,11 @@
 ---
 name: simple
+group: tests
 dir_path: "/tmp/"
 num_trials: 3
-dry_run: True
 max_time: 100
 interval: 1
 seed: "CompleteSeed!"
-dump: false
 network_params:
   generator: complete_graph
   n: 10
@@ -14,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

@@ -0,0 +1,16 @@
+---
+name: custom-generator
+description: Using a custom generator for the network
+num_trials: 3
+max_time: 100
+interval: 1
+network_params:
+  generator: mymodule.mygenerator
+# These are custom parameters
+  n: 10
+  n_edges: 5  
+network_agents:
+  - agent_type: CounterModel
+    weight: 1
+    state:
+      state_id: 0

examples/custom_generator/mymodule.py

@@ -0,0 +1,27 @@
+from networkx import Graph
+import networkx as nx
+from random import choice
+
+def mygenerator(n=5, n_edges=5):
+    '''
+    Just a simple generator that creates a network with n nodes and
+    n_edges edges. Edges are assigned randomly, only avoiding self loops.
+    '''
+    G = nx.Graph()
+
+    for i in range(n):
+        G.add_node(i)
+    
+    for i in range(n_edges):
+        nodes = list(G.nodes)
+        n_in = choice(nodes)
+        nodes.remove(n_in)  # Avoid loops
+        n_out = choice(nodes)
+        G.add_edge(n_in, n_out)
+    return G
+    
+
+
+
+
+    

examples/custom_timeouts/custom_timeouts.py

@@ -0,0 +1,35 @@
+from soil.agents import FSM, state, default_state
+
+
+class Fibonacci(FSM):
+    '''Agent that only executes in t_steps that are Fibonacci numbers'''
+
+    defaults = {
+        'prev': 1
+    }
+
+    @default_state
+    @state
+    def counting(self):
+        self.log('Stopping at {}'.format(self.now))
+        prev, self['prev'] = self['prev'], max([self.now, self['prev']])
+        return None, self.env.timeout(prev)
+
+class Odds(FSM):
+    '''Agent that only executes in odd t_steps'''
+    @default_state
+    @state
+    def odds(self):
+        self.log('Stopping at {}'.format(self.now))
+        return None, self.env.timeout(1+self.now%2)
+
+if __name__ == '__main__':
+    import logging
+    logging.basicConfig(level=logging.INFO)
+    from soil import Simulation
+    s = Simulation(network_agents=[{'ids': [0], 'agent_type': Fibonacci},
+                                   {'ids': [1], 'agent_type': Odds}],
+                   network_params={"generator": "complete_graph", "n": 2},
+                   max_time=100,
+                   )
+    s.run(dry_run=True)

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

@@ -6,7 +6,7 @@ environment_params:
   prob_neighbor_spread: 0.0
   prob_tv_spread: 0.01
 interval: 1
-max_time: 30
+max_time: 300
 name: Sim_all_dumb
 network_agents:
 - agent_type: DumbViewer
@@ -30,7 +30,7 @@ environment_params:
   prob_neighbor_spread: 0.0
   prob_tv_spread: 0.01
 interval: 1
-max_time: 30
+max_time: 300
 name: Sim_half_herd
 network_agents:
 - agent_type: DumbViewer
@@ -62,18 +62,18 @@ environment_params:
   prob_neighbor_spread: 0.0
   prob_tv_spread: 0.01
 interval: 1
-max_time: 30
+max_time: 300
 name: Sim_all_herd
 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
@@ -89,13 +89,13 @@ environment_params:
   prob_tv_spread: 0.01
   prob_neighbor_cure: 0.1
 interval: 1
-max_time: 30
+max_time: 300
 name: Sim_wise_herd
 network_agents:
 - agent_type: HerdViewer
   state:
     has_tv: true
-    id: neutral
+    state_id: neutral
   weight: 1
 - agent_type: WiseViewer
   state:
@@ -115,13 +115,13 @@ environment_params:
   prob_tv_spread: 0.01
   prob_neighbor_cure: 0.1
 interval: 1
-max_time: 30
+max_time: 300
 name: Sim_all_wise
 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/.gitignore

@@ -0,0 +1 @@
+Programmatic*

examples/programmatic/programmatic.py

@@ -0,0 +1,40 @@
+'''
+Example of a fully programmatic simulation, without definition files.
+'''
+from soil import Simulation, agents
+from networkx import Graph
+import logging
+
+
+def mygenerator():
+    # Add only a node
+    G = Graph()
+    G.add_node(1)
+    return G
+
+
+class MyAgent(agents.FSM):
+
+    @agents.default_state
+    @agents.state
+    def neutral(self):
+        self.debug('I am running')
+        if agents.prob(0.2):
+            self.info('This runs 2/10 times on average')
+
+
+s = Simulation(name='Programmatic',
+               network_params={'generator': mygenerator},
+               num_trials=1,
+               max_time=100,
+               agent_type=MyAgent,
+               dry_run=True)
+
+
+# By default, logging will only print WARNING logs (and above).
+# You need to choose a lower logging level to get INFO/DEBUG traces
+logging.basicConfig(level=logging.INFO)
+envs = s.run()
+
+# Uncomment this to output the simulation to a YAML file
+# s.dump_yaml('simulation.yaml')

examples/pubcrawl/pubcrawl.py

@@ -59,7 +59,7 @@ class Patron(FSM):
         2) Look for a bar where the agent and other agents in the same group can get in.
         3) While in the bar, patrons only drink, until they get drunk and taken home.
     '''
-    level = logging.INFO
+    level = logging.DEBUG
 
     defaults = {
         'pub': None,
@@ -113,7 +113,8 @@ class Patron(FSM):
     @state
     def at_home(self):
         '''The end'''
-        self.debug('Life sucks. I\'m home!')
+        others = self.get_agents(state_id=Patron.at_home.id, limit_neighbors=True)
+        self.debug('I\'m home. Just like {} of my friends'.format(len(others)))
     
     def drink(self):
         self['pints'] += 1

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

@@ -0,0 +1,30 @@
+---
+sampler:
+  method: "SALib.sample.morris.sample"
+  N: 10
+template:
+  group: simple
+  num_trials: 1
+  interval: 1
+  max_time: 2
+  seed: "CompleteSeed!"
+  dump: false
+  network_params:
+    generator: complete_graph
+    n: 10
+  network_agents:
+    - agent_type: CounterModel
+      weight: "{{ x1 }}"
+      state:
+        state_id: 0
+    - agent_type: AggregatedCounter
+      weight: "{{ 1 - x1 }}"
+  environment_params:
+    name: "{{ x3 }}"
+  skip_test: true
+vars:
+  bounds:
+    x1: [0, 1]
+    x2: [1, 2]
+  fixed:
+    x3: ["a", "b", "c"]

examples/terrorism/TerroristNetworkModel.py

@@ -0,0 +1,208 @@
+import random
+import networkx as nx
+from soil.agents import Geo, NetworkAgent, FSM, state, default_state
+from soil import Environment
+
+
+class TerroristSpreadModel(FSM, Geo):
+    """
+    Settings:
+        information_spread_intensity
+
+        terrorist_additional_influence
+
+        min_vulnerability (optional else zero)
+
+        max_vulnerability
+
+        prob_interaction
+    """
+
+    def __init__(self, model=None, unique_id=0, state=()):
+        super().__init__(model=model, unique_id=unique_id, state=state)
+
+        self.information_spread_intensity = model.environment_params['information_spread_intensity']
+        self.terrorist_additional_influence = model.environment_params['terrorist_additional_influence']
+        self.prob_interaction = model.environment_params['prob_interaction']
+
+        if self['id'] == self.civilian.id:       # Civilian
+            self.mean_belief = random.uniform(0.00, 0.5)
+        elif self['id'] == self.terrorist.id:     # Terrorist
+            self.mean_belief = random.uniform(0.8, 1.00)
+        elif self['id'] == self.leader.id:     # Leader
+            self.mean_belief = 1.00
+        else:
+            raise Exception('Invalid state id: {}'.format(self['id']))
+
+        if 'min_vulnerability' in model.environment_params:
+            self.vulnerability = random.uniform( model.environment_params['min_vulnerability'], model.environment_params['max_vulnerability'] )
+        else :
+            self.vulnerability = random.uniform( 0, model.environment_params['max_vulnerability'] )
+
+
+    @state
+    def civilian(self):
+        neighbours = list(self.get_neighboring_agents(agent_type=TerroristSpreadModel))
+        if len(neighbours) > 0:
+            # Only interact with some of the neighbors
+            interactions = list(n for n in neighbours if random.random() <= self.prob_interaction)
+            influence = sum( self.degree(i) for i in interactions )
+            mean_belief = sum( i.mean_belief * self.degree(i) / influence for i in interactions )
+            mean_belief = mean_belief * self.information_spread_intensity + self.mean_belief * ( 1 - self.information_spread_intensity )
+            self.mean_belief = mean_belief * self.vulnerability + self.mean_belief * ( 1 - self.vulnerability )
+        
+        if self.mean_belief >= 0.8:
+            return self.terrorist
+
+    @state
+    def leader(self):
+        self.mean_belief = self.mean_belief ** ( 1 - self.terrorist_additional_influence )
+        for neighbour in self.get_neighboring_agents(state_id=[self.terrorist.id, self.leader.id]):
+            if self.betweenness(neighbour) > self.betweenness(self):
+                return self.terrorist
+
+    @state
+    def terrorist(self):
+        neighbours = self.get_agents(state_id=[self.terrorist.id, self.leader.id],
+                                     agent_type=TerroristSpreadModel,
+                                     limit_neighbors=True)
+        if len(neighbours) > 0:
+            influence = sum( self.degree(n) for n in neighbours )
+            mean_belief = sum( n.mean_belief * self.degree(n) / influence for n in neighbours )
+            mean_belief = mean_belief * self.vulnerability + self.mean_belief * ( 1 - self.vulnerability )
+            self.mean_belief = self.mean_belief ** ( 1 - self.terrorist_additional_influence )
+
+        # Check if there are any leaders in the group
+        leaders = list(filter(lambda x: x.state.id == self.leader.id, neighbours))
+        if not leaders:
+            # Check if this is the potential leader
+            # Stop once it's found. Otherwise, set self as leader
+            for neighbour in neighbours:
+                if self.betweenness(self) < self.betweenness(neighbour):
+                    return
+            return self.leader
+
+
+class TrainingAreaModel(FSM, Geo):
+    """
+    Settings:
+        training_influence
+
+        min_vulnerability
+
+    Requires TerroristSpreadModel.
+    """
+
+    def __init__(self, model=None, unique_id=0, state=()):
+        super().__init__(model=model, unique_id=unique_id, state=state)
+        self.training_influence = model.environment_params['training_influence']
+        if 'min_vulnerability' in model.environment_params:
+            self.min_vulnerability = model.environment_params['min_vulnerability']
+        else: self.min_vulnerability = 0
+
+    @default_state
+    @state
+    def terrorist(self):
+        for neighbour in self.get_neighboring_agents(agent_type=TerroristSpreadModel):
+            if neighbour.vulnerability > self.min_vulnerability:
+                neighbour.vulnerability = neighbour.vulnerability ** ( 1 - self.training_influence )        
+
+
+class HavenModel(FSM, Geo):
+    """
+    Settings:
+        haven_influence
+
+        min_vulnerability
+
+        max_vulnerability
+
+    Requires TerroristSpreadModel.
+    """
+
+    def __init__(self, model=None, unique_id=0, state=()):
+        super().__init__(model=model, unique_id=unique_id, state=state)
+        self.haven_influence = model.environment_params['haven_influence']
+        if 'min_vulnerability' in model.environment_params:
+            self.min_vulnerability = model.environment_params['min_vulnerability']
+        else: self.min_vulnerability = 0
+        self.max_vulnerability = model.environment_params['max_vulnerability']
+
+    def get_occupants(self, **kwargs):
+        return self.get_neighboring_agents(agent_type=TerroristSpreadModel, **kwargs)
+
+    @state
+    def civilian(self):
+        civilians = self.get_occupants(state_id=self.civilian.id)
+        if not civilians:
+            return self.terrorist
+
+        for neighbour in self.get_occupants():
+            if neighbour.vulnerability > self.min_vulnerability:
+                neighbour.vulnerability = neighbour.vulnerability * ( 1 - self.haven_influence )
+        return self.civilian
+
+    @state
+    def terrorist(self):
+        for neighbour in self.get_occupants():
+            if neighbour.vulnerability < self.max_vulnerability:
+                neighbour.vulnerability = neighbour.vulnerability ** ( 1 - self.haven_influence )
+        return self.terrorist
+
+
+class TerroristNetworkModel(TerroristSpreadModel):
+    """
+    Settings:
+        sphere_influence
+
+        vision_range
+
+        weight_social_distance
+
+        weight_link_distance
+    """
+
+    def __init__(self, model=None, unique_id=0, state=()):
+        super().__init__(model=model, unique_id=unique_id, state=state)
+
+        self.vision_range = model.environment_params['vision_range']
+        self.sphere_influence = model.environment_params['sphere_influence']
+        self.weight_social_distance = model.environment_params['weight_social_distance']
+        self.weight_link_distance = model.environment_params['weight_link_distance']
+
+    @state
+    def terrorist(self):
+        self.update_relationships()
+        return super().terrorist()
+
+    @state
+    def leader(self):
+        self.update_relationships()
+        return super().leader()
+
+    def update_relationships(self):
+        if self.count_neighboring_agents(state_id=self.civilian.id) == 0:
+            close_ups = set(self.geo_search(radius=self.vision_range, agent_type=TerroristNetworkModel))
+            step_neighbours = set(self.ego_search(self.sphere_influence, agent_type=TerroristNetworkModel, center=False))
+            neighbours = set(agent.id for agent in self.get_neighboring_agents(agent_type=TerroristNetworkModel))
+            search = (close_ups | step_neighbours) - neighbours
+            for agent in self.get_agents(search):
+                social_distance = 1 / self.shortest_path_length(agent.id)
+                spatial_proximity = ( 1 - self.get_distance(agent.id) )
+                prob_new_interaction = self.weight_social_distance * social_distance + self.weight_link_distance * spatial_proximity
+                if agent['id'] == agent.civilian.id and random.random() < prob_new_interaction:
+                    self.add_edge(agent)
+                    break
+
+    def get_distance(self, target):
+        source_x, source_y = nx.get_node_attributes(self.topology, 'pos')[self.id]
+        target_x, target_y = nx.get_node_attributes(self.topology, 'pos')[target]
+        dx = abs( source_x - target_x )
+        dy = abs( source_y - target_y )
+        return ( dx ** 2 + dy ** 2 ) ** ( 1 / 2 )
+
+    def shortest_path_length(self, target):
+        try:
+            return nx.shortest_path_length(self.topology, self.id, target)
+        except nx.NetworkXNoPath:
+            return float('inf')

examples/terrorism/TerroristNetworkModel.yml

@@ -60,3 +60,4 @@ visualization_params:
   background_image: 'map_4800x2860.jpg'
   background_opacity: '0.9'
   background_filter_color: 'blue'
+skip_test: true  # This simulation takes too long for automated tests.

requirements.txt

@@ -1,7 +1,9 @@
-nxsim
-simpy
-networkx>=2.0
+networkx>=2.5
 numpy
 matplotlib
-pyyaml
-pandas
+pyyaml>=5.1
+pandas>=0.23
+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.13.1
+0.20.8

soil/__init__.py

@@ -11,23 +11,28 @@ try:
 except NameError:
     basestring = str
 
-logging.basicConfig()
-
+from .agents import *
 from . import agents
 from .simulation import *
 from .environment import Environment
-from . import utils
+from . import serialization
 from . import analysis
+from .utils import logger
+from .time import *
 
 def main():
     import argparse
     from . import simulation
 
+    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',
@@ -38,32 +43,51 @@ 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',
                         help='Run trials serially and synchronously instead of in parallel. Defaults to false.')
+    parser.add_argument('-e', '--exporter', action='append',
+                        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:
-        dump = []
-        if not args.dry_run:
-            if args.csv:
-                dump.append('csv')
-            if args.graph:
-                dump.append('gexf')
+        exporters = list(args.exporter or ['default', ])
+        if args.csv:
+            exporters.append('csv')
+        if args.graph:
+            exporters.append('gexf')
+        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,
-                                   dump=dump,
-                                   parallel=(not args.synchronous and not args.pdb),
-                                   results_dir=args.output)
+                                   exporters=exporters,
+                                   parallel=(not args.synchronous),
+                                   outdir=args.output,
+                                   exporter_params=exp_params)
     except Exception:
         if args.pdb:
             pdb.post_mortem()

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,24 +9,30 @@ 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.
     """
 
+    defaults = {
+        'times': 0,
+        'neighbors': 0,
+        'total': 0
+    }
+
     def step(self):
         # Outside effects
-        total = len(list(self.get_all_agents()))
+        self['times'] += 1
         neighbors = len(list(self.get_neighboring_agents()))
-        self['times'] = self.get('times', 0) + 1
-        self['neighbors'] = self.get('neighbors', 0) + neighbors
-        self['total'] = total = self.get('total', 0) + total
+        self['neighbors'] += neighbors
+        total = len(list(self.get_agents()))
+        self['total'] += total
         self.debug('Running for step: {}. Total: {}'.format(self.now, total))

soil/agents/DrawingAgent.py

@@ -1,18 +0,0 @@
-from . import BaseAgent
-
-import os.path
-import matplotlib
-import matplotlib.pyplot as plt
-import networkx as nx
-
-
-class DrawingAgent(BaseAgent):
-    """
-    Agent that draws the state of the network.
-    """
-
-    def step(self):
-        # Outside effects
-        f = plt.figure()
-        nx.draw(self.env.G, node_size=10, width=0.2, pos=nx.spring_layout(self.env.G, scale=100), ax=f.add_subplot(111))
-        f.savefig(os.path.join(self.env.get_path(), "graph-"+str(self.env.now)+".png"))

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'])