WIP soil

* Pandas integration
* Improved environment
* Logging and data dumps
* Tests
* Added Finite State Machine models
* Rewritten ipython notebook and documentation

soil/__init__.py

@@ -0,0 +1,42 @@
+import importlib
+import sys
+import os
+
+__version__ = "0.9.2"
+
+try:
+    basestring
+except NameError:
+    basestring = str
+
+from . import agents
+from . import simulation
+from . import environment
+from . import utils
+from . import settings
+
+
+def main():
+    import argparse
+    from . import simulation
+
+    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.')
+    parser.add_argument('--module', '-m', type=str,
+                        help='file containing the code of any custom agents.')
+
+    args = parser.parse_args()
+
+    if args.module:
+        sys.path.append(os.getcwd())
+        importlib.import_module(args.module)
+
+    print('Loading config file: {}'.format(args.file))
+    simulation.run_from_config(args.file)
+
+
+if __name__ == '__main__':
+    main()

soil/agents/BaseBehaviour.py

@@ -0,0 +1,123 @@
+import nxsim
+from collections import OrderedDict
+from copy import deepcopy
+import json
+
+from functools import wraps
+
+
+class BaseAgent(nxsim.BaseAgent):
+    """
+    A special simpy BaseAgent that keeps track of its state history.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self._history = OrderedDict()
+        self._neighbors = None
+        super().__init__(*args, **kwargs)
+        self._history[None] = deepcopy(self.state)
+
+    @property
+    def now(self):
+        try:
+            return self.env.now
+        except AttributeError:
+            # No environment
+            return None
+
+    def run(self):
+        while True:
+            res = self.step()
+            self._history[self.env.now] = deepcopy(self.state)
+            yield res or self.env.timeout(self.env.interval)
+
+    def step(self):
+        pass
+
+    def to_json(self):
+        return json.dumps(self._history)
+
+class NetworkAgent(BaseAgent, nxsim.BaseNetworkAgent):
+
+    def count_agents(self, state_id=None, limit_neighbors=False):
+        if limit_neighbors:
+            agents = self.global_topology.neighbors(self.id)
+        else:
+            agents = self.global_topology.nodes()
+        count = 0
+        for agent in agents:
+            if state_id and state_id != self.global_topology.node[agent]['agent'].state['id']:
+                continue
+            count += 1
+        return count
+
+    def count_neighboring_agents(self, state_id=None):
+        return self.count_agents(state_id, limit_neighbors=True)
+
+
+def state(func):
+
+    @wraps(func)
+    def func_wrapper(self):
+        when = None
+        next_state = func(self)
+        try:
+            next_state, when = next_state
+        except TypeError:
+            pass
+        if next_state:
+            try:
+                self.state['id'] = next_state.id
+            except AttributeError:
+                raise NotImplemented('State id %s is not valid.' % next_state)
+        return when
+
+    func_wrapper.id = func.__name__
+    func_wrapper.is_default = False
+    return func_wrapper
+
+
+def default_state(func):
+    func.is_default = True
+    return func
+
+
+class MetaFSM(type):
+    def __init__(cls, name, bases, nmspc):
+        super(MetaFSM, cls).__init__(name, bases, nmspc)
+        states = {}
+        # Re-use states from inherited classes
+        default_state = None
+        for i in bases:
+            if isinstance(i, MetaFSM):
+                for state_id, state in i.states.items():
+                    if state.is_default:
+                        default_state = state
+                    states[state_id] = state
+
+        # Add new states
+        for name, func in nmspc.items():
+            if hasattr(func, 'id'):
+                if func.is_default:
+                    default_state = func
+                states[func.id] = func
+        cls.default_state = default_state
+        cls.states = states
+
+
+class FSM(BaseAgent, metaclass=MetaFSM):
+    def __init__(self, *args, **kwargs):
+        super(FSM, self).__init__(*args, **kwargs)
+        if 'id' not in self.state:
+            self.state['id'] = self.default_state.id
+
+    def step(self):
+        if 'id' in self.state:
+            next_state = self.state['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))
+        self.states[next_state](self)

soil/agents/BassModel.py

@@ -0,0 +1,40 @@
+import random
+from . import NetworkAgent
+
+
+class BassModel(NetworkAgent):
+    """
+    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
+
+    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)
+            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
+
+            else:
+                pass

soil/agents/BigMarketModel.py

@@ -0,0 +1,102 @@
+import random
+from . import NetworkAgent
+
+
+class BigMarketModel(NetworkAgent):
+    """
+    Settings:
+        Names:
+            enterprises [Array]
+            
+            tweet_probability_enterprises [Array]
+        Users:
+            tweet_probability_users
+            
+            tweet_relevant_probability
+            
+            tweet_probability_about [Array]
+            
+            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']
+        self.type = ""
+        self.number_of_enterprises = len(environment.environment_params['enterprises'])
+
+        if self.id < self.number_of_enterprises:  # Enterprises
+            self.state['id'] = self.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.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):
+
+        if random.random() < self.tweet_probability:  # Tweets
+            aware_neighbors = self.get_neighboring_agents(state_id=self.number_of_enterprises)  # Nodes neighbour users
+            for x in aware_neighbors:
+                if random.uniform(0,10) < 5:
+                    x.sentiment_about[self.id] += 0.1  # Increments for enterprise
+                else:
+                    x.sentiment_about[self.id] -= 0.1  # Decrements for enterprise
+
+                # Establecemos limites
+                if x.sentiment_about[self.id] > 1:
+                    x.sentiment_about[self.id] = 1
+                if x.sentiment_about[self.id]< -1:
+                    x.sentiment_about[self.id] = -1
+
+                x.attrs['sentiment_enterprise_%s'% self.enterprises[self.id]] = x.sentiment_about[self.id]
+
+    def userBehaviour(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):
+                    random_num = random.random()
+                    if random_num < self.tweet_probability_about[i]:
+                        # The condition is fulfilled, sentiments are evaluated towards that enterprise
+                        if self.sentiment_about[i] < 0:
+                            # NEGATIVO
+                            self.userTweets("negative",i)
+                        elif self.sentiment_about[i] == 0:
+                            # NEUTRO
+                            pass
+                        else:
+                            # POSITIVO
+                            self.userTweets("positive",i)
+
+    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":
+                x.sentiment_about[enterprise] +=0.003
+            elif sentiment == "negative":
+                x.sentiment_about[enterprise] -=0.003
+            else:
+                pass
+
+            # Establecemos limites
+            if x.sentiment_about[enterprise] > 1:
+                x.sentiment_about[enterprise] = 1
+            if x.sentiment_about[enterprise] < -1:
+                x.sentiment_about[enterprise] = -1
+
+            x.attrs['sentiment_enterprise_%s'% self.enterprises[enterprise]] = x.sentiment_about[enterprise]

soil/agents/CounterModel.py

@@ -0,0 +1,31 @@
+from . import NetworkAgent
+
+
+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.
+    """
+
+    def step(self):
+        # Outside effects
+        total = len(self.get_all_agents())
+        neighbors = len(self.get_neighboring_agents())
+        self.state['times'] = self.state.get('times', 0) + 1
+        self.state['neighbors'] = neighbors
+        self.state['total'] = total
+
+
+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.
+    """
+
+    def step(self):
+        # Outside effects
+        total = len(self.get_all_agents())
+        neighbors = len(self.get_neighboring_agents())
+        self.state['times'] = self.state.get('times', 0) + 1
+        self.state['neighbors'] = self.state.get('neighbors', 0) + neighbors
+        self.state['total'] = self.state.get('total', 0) + total

soil/agents/DrawingAgent.py

@@ -0,0 +1,18 @@
+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.sim().dir_path, "graph-"+str(self.env.now)+".png"))

soil/agents/IndependentCascadeModel.py

@@ -0,0 +1,49 @@
+import random
+from . import BaseAgent
+
+
+class IndependentCascadeModel(BaseAgent):
+    """
+    Settings:
+        innovation_prob
+
+        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']
+        self.state['time_awareness'] = 0
+        self.state['sentimentCorrelation'] = 0
+
+    def step(self):
+        self.behaviour()
+
+    def behaviour(self):
+        aware_neighbors_1_time_step = []
+        # Outside effects
+        if random.random() < self.innovation_prob:
+            if self.state['id'] == 0:
+                self.state['id'] = 1
+                self.state['sentimentCorrelation'] = 1
+                self.state['time_awareness'] = self.env.now  # To know when they have been infected
+            else:
+                pass
+
+            return
+
+        # Imitation effects
+        if self.state['id'] == 0:
+            aware_neighbors = self.get_neighboring_agents(state_id=1)
+            for x in aware_neighbors:
+                if x.state['time_awareness'] == (self.env.now-1):
+                    aware_neighbors_1_time_step.append(x)
+            num_neighbors_aware = len(aware_neighbors_1_time_step)
+            if random.random() < (self.imitation_prob*num_neighbors_aware):
+                self.state['id'] = 1
+                self.state['sentimentCorrelation'] = 1
+            else:
+                pass
+
+            return

soil/agents/ModelM2.py

@@ -0,0 +1,242 @@
+import random
+import numpy as np
+from . import NetworkAgent
+
+
+class SpreadModelM2(NetworkAgent):
+    """
+    Settings:
+        prob_neutral_making_denier
+
+        prob_infect
+
+        prob_cured_healing_infected
+
+        prob_cured_vaccinate_neutral
+
+        prob_vaccinated_healing_infected
+
+        prob_vaccinated_vaccinate_neutral
+
+        prob_generate_anti_rumor
+    """
+
+    def __init__(self, environment=None, agent_id=0, state=()):
+        super().__init__(environment=environment, agent_id=agent_id, state=state)
+
+        self.prob_neutral_making_denier = np.random.normal(environment.environment_params['prob_neutral_making_denier'],
+                                                           environment.environment_params['standard_variance'])
+
+        self.prob_infect = np.random.normal(environment.environment_params['prob_infect'],
+                                            environment.environment_params['standard_variance'])
+
+        self.prob_cured_healing_infected = np.random.normal(environment.environment_params['prob_cured_healing_infected'],
+                                                            environment.environment_params['standard_variance'])
+        self.prob_cured_vaccinate_neutral = np.random.normal(environment.environment_params['prob_cured_vaccinate_neutral'],
+                                                             environment.environment_params['standard_variance'])
+
+        self.prob_vaccinated_healing_infected = np.random.normal(environment.environment_params['prob_vaccinated_healing_infected'],
+                                                                 environment.environment_params['standard_variance'])
+        self.prob_vaccinated_vaccinate_neutral = np.random.normal(environment.environment_params['prob_vaccinated_vaccinate_neutral'],
+                                                                  environment.environment_params['standard_variance'])
+        self.prob_generate_anti_rumor = np.random.normal(environment.environment_params['prob_generate_anti_rumor'],
+                                                         environment.environment_params['standard_variance'])
+
+    def step(self):
+
+        if self.state['id'] == 0:  # Neutral
+            self.neutral_behaviour()
+        elif self.state['id'] == 1:  # Infected
+            self.infected_behaviour()
+        elif self.state['id'] == 2:  # Cured
+            self.cured_behaviour()
+        elif self.state['id'] == 3:  # Vaccinated
+            self.vaccinated_behaviour()
+
+    def neutral_behaviour(self):
+
+        # Infected
+        infected_neighbors = self.get_neighboring_agents(state_id=1)
+        if len(infected_neighbors) > 0:
+            if random.random() < self.prob_neutral_making_denier:
+                self.state['id'] = 3   # Vaccinated making denier
+
+    def infected_behaviour(self):
+
+        # Neutral
+        neutral_neighbors = self.get_neighboring_agents(state_id=0)
+        for neighbor in neutral_neighbors:
+            if random.random() < self.prob_infect:
+                neighbor.state['id'] = 1  # Infected
+
+    def cured_behaviour(self):
+
+        # Vaccinate
+        neutral_neighbors = self.get_neighboring_agents(state_id=0)
+        for neighbor in neutral_neighbors:
+            if random.random() < self.prob_cured_vaccinate_neutral:
+                neighbor.state['id'] = 3  # Vaccinated
+
+        # Cure
+        infected_neighbors = self.get_neighboring_agents(state_id=1)
+        for neighbor in infected_neighbors:
+            if random.random() < self.prob_cured_healing_infected:
+                neighbor.state['id'] = 2  # Cured
+
+    def vaccinated_behaviour(self):
+
+        # Cure
+        infected_neighbors = self.get_neighboring_agents(state_id=1)
+        for neighbor in infected_neighbors:
+            if random.random() < self.prob_cured_healing_infected:
+                neighbor.state['id'] = 2  # Cured
+
+        # Vaccinate
+        neutral_neighbors = self.get_neighboring_agents(state_id=0)
+        for neighbor in neutral_neighbors:
+            if random.random() < self.prob_cured_vaccinate_neutral:
+                neighbor.state['id'] = 3  # Vaccinated
+
+        # Generate anti-rumor
+        infected_neighbors_2 = self.get_neighboring_agents(state_id=1)
+        for neighbor in infected_neighbors_2:
+            if random.random() < self.prob_generate_anti_rumor:
+                neighbor.state['id'] = 2  # Cured
+
+
+class ControlModelM2(NetworkAgent):
+    """
+    Settings:
+        prob_neutral_making_denier
+
+        prob_infect
+        
+        prob_cured_healing_infected
+        
+        prob_cured_vaccinate_neutral
+        
+        prob_vaccinated_healing_infected
+        
+        prob_vaccinated_vaccinate_neutral
+        
+        prob_generate_anti_rumor
+    """
+
+
+    def __init__(self, environment=None, agent_id=0, state=()):
+        super().__init__(environment=environment, agent_id=agent_id, state=state)
+
+        self.prob_neutral_making_denier = np.random.normal(environment.environment_params['prob_neutral_making_denier'],
+                                                           environment.environment_params['standard_variance'])
+
+        self.prob_infect = np.random.normal(environment.environment_params['prob_infect'],
+                                            environment.environment_params['standard_variance'])
+
+        self.prob_cured_healing_infected = np.random.normal(environment.environment_params['prob_cured_healing_infected'],
+                                                            environment.environment_params['standard_variance'])
+        self.prob_cured_vaccinate_neutral = np.random.normal(environment.environment_params['prob_cured_vaccinate_neutral'],
+                                                             environment.environment_params['standard_variance'])
+
+        self.prob_vaccinated_healing_infected = np.random.normal(environment.environment_params['prob_vaccinated_healing_infected'],
+                                                                 environment.environment_params['standard_variance'])
+        self.prob_vaccinated_vaccinate_neutral = np.random.normal(environment.environment_params['prob_vaccinated_vaccinate_neutral'],
+                                                                  environment.environment_params['standard_variance'])
+        self.prob_generate_anti_rumor = np.random.normal(environment.environment_params['prob_generate_anti_rumor'],
+                                                         environment.environment_params['standard_variance'])
+
+    def step(self):
+
+        if self.state['id'] == 0:  # Neutral
+            self.neutral_behaviour()
+        elif self.state['id'] == 1:  # Infected
+            self.infected_behaviour()
+        elif self.state['id'] == 2:  # Cured
+            self.cured_behaviour()
+        elif self.state['id'] == 3:  # Vaccinated
+            self.vaccinated_behaviour()
+        elif self.state['id'] == 4:  # Beacon-off
+            self.beacon_off_behaviour()
+        elif self.state['id'] == 5:  # Beacon-on
+            self.beacon_on_behaviour()
+
+    def neutral_behaviour(self):
+        self.state['visible'] = False
+
+        # Infected
+        infected_neighbors = self.get_neighboring_agents(state_id=1)
+        if len(infected_neighbors) > 0:
+            if random.random() < self.prob_neutral_making_denier:
+                self.state['id'] = 3   # Vaccinated making denier
+
+    def infected_behaviour(self):
+
+        # Neutral
+        neutral_neighbors = self.get_neighboring_agents(state_id=0)
+        for neighbor in neutral_neighbors:
+            if random.random() < self.prob_infect:
+                neighbor.state['id'] = 1  # Infected
+        self.state['visible'] = False
+
+    def cured_behaviour(self):
+
+        self.state['visible'] = True
+        # Vaccinate
+        neutral_neighbors = self.get_neighboring_agents(state_id=0)
+        for neighbor in neutral_neighbors:
+            if random.random() < self.prob_cured_vaccinate_neutral:
+                neighbor.state['id'] = 3  # Vaccinated
+
+        # Cure
+        infected_neighbors = self.get_neighboring_agents(state_id=1)
+        for neighbor in infected_neighbors:
+            if random.random() < self.prob_cured_healing_infected:
+                neighbor.state['id'] = 2  # Cured
+
+    def vaccinated_behaviour(self):
+        self.state['visible'] = True
+
+        # Cure
+        infected_neighbors = self.get_neighboring_agents(state_id=1)
+        for neighbor in infected_neighbors:
+            if random.random() < self.prob_cured_healing_infected:
+                neighbor.state['id'] = 2  # Cured
+
+        # Vaccinate
+        neutral_neighbors = self.get_neighboring_agents(state_id=0)
+        for neighbor in neutral_neighbors:
+            if random.random() < self.prob_cured_vaccinate_neutral:
+                neighbor.state['id'] = 3  # Vaccinated
+
+        # Generate anti-rumor
+        infected_neighbors_2 = self.get_neighboring_agents(state_id=1)
+        for neighbor in infected_neighbors_2:
+            if random.random() < self.prob_generate_anti_rumor:
+                neighbor.state['id'] = 2  # Cured
+
+    def beacon_off_behaviour(self):
+        self.state['visible'] = False
+        infected_neighbors = self.get_neighboring_agents(state_id=1)
+        if len(infected_neighbors) > 0:
+            self.state['id'] == 5  # Beacon on
+
+    def beacon_on_behaviour(self):
+        self.state['visible'] = False
+        # Cure (M2 feature added)
+        infected_neighbors = self.get_neighboring_agents(state_id=1)
+        for neighbor in infected_neighbors:
+            if random.random() < self.prob_generate_anti_rumor:
+                neighbor.state['id'] = 2  # Cured
+            neutral_neighbors_infected = neighbor.get_neighboring_agents(state_id=0)
+            for neighbor in neutral_neighbors_infected:
+                if random.random() < self.prob_generate_anti_rumor:
+                    neighbor.state['id'] = 3  # Vaccinated
+            infected_neighbors_infected = neighbor.get_neighboring_agents(state_id=1)
+            for neighbor in infected_neighbors_infected:
+                if random.random() < self.prob_generate_anti_rumor:
+                    neighbor.state['id'] = 2  # Cured
+
+        # Vaccinate
+        neutral_neighbors = self.get_neighboring_agents(state_id=0)
+        for neighbor in neutral_neighbors:
+            if random.random() < self.prob_cured_vaccinate_neutral:
+                neighbor.state['id'] = 3  # Vaccinated

soil/agents/SISaModel.py

@@ -0,0 +1,93 @@
+import random
+import numpy as np
+from . import FSM, state
+
+
+class SISaModel(FSM):
+    """
+    Settings:
+        neutral_discontent_spon_prob
+        
+        neutral_discontent_infected_prob
+        
+        neutral_content_spong_prob
+        
+        neutral_content_infected_prob
+        
+        discontent_neutral
+        
+        discontent_content
+        
+        variance_d_c
+        
+        content_discontent
+        
+        variance_c_d
+        
+        content_neutral
+        
+        standard_variance
+    """
+
+    def __init__(self, environment=None, agent_id=0, state=()):
+        super().__init__(environment=environment, agent_id=agent_id, state=state)
+
+        self.neutral_discontent_spon_prob = np.random.normal(environment.environment_params['neutral_discontent_spon_prob'],
+                                                             environment.environment_params['standard_variance'])
+        self.neutral_discontent_infected_prob = np.random.normal(environment.environment_params['neutral_discontent_infected_prob'],
+                                                                 environment.environment_params['standard_variance'])
+        self.neutral_content_spon_prob = np.random.normal(environment.environment_params['neutral_content_spon_prob'],
+                                                          environment.environment_params['standard_variance'])
+        self.neutral_content_infected_prob = np.random.normal(environment.environment_params['neutral_content_infected_prob'],
+                                                              environment.environment_params['standard_variance'])
+
+        self.discontent_neutral = np.random.normal(environment.environment_params['discontent_neutral'],
+                                                   environment.environment_params['standard_variance'])
+        self.discontent_content = np.random.normal(environment.environment_params['discontent_content'],
+                                                   environment.environment_params['variance_d_c'])
+
+        self.content_discontent = np.random.normal(environment.environment_params['content_discontent'],
+                                                   environment.environment_params['variance_c_d'])
+        self.content_neutral = np.random.normal(environment.environment_params['content_neutral'],
+                                                environment.environment_params['standard_variance'])
+
+    @state
+    def neutral(self):
+        # Spontaneous effects
+        if random.random() < self.neutral_discontent_spon_prob:
+            return self.discontent
+        if random.random() < self.neutral_content_spon_prob:
+            return self.content
+
+        # Infected
+        discontent_neighbors = self.count_neighboring_agents(state_id=self.discontent)
+        if random.random() < discontent_neighbors * self.neutral_discontent_infected_prob:
+            return self.discontent
+        content_neighbors = self.count_neighboring_agents(state_id=self.content.id)
+        if random.random() < content_neighbors * self.neutral_content_infected_prob:
+            return self.content
+        return self.neutral
+
+    @state
+    def discontent(self):
+        # Healing
+        if random.random() < self.discontent_neutral:
+            return self.neutral
+
+        # Superinfected
+        content_neighbors = self.count_neighboring_agents(state_id=self.content.id)
+        if random.random() < content_neighbors * self.discontent_content:
+            return self.content
+        return self.discontent
+
+    @state
+    def content(self):
+        # Healing
+        if random.random() < self.content_neutral:
+            return self.neutral
+
+        # Superinfected
+        discontent_neighbors = self.count_neighboring_agents(state_id=self.discontent.id)
+        if random.random() < discontent_neighbors * self.content_discontent:
+            self.discontent
+        return self.content

soil/agents/SentimentCorrelationModel.py

@@ -0,0 +1,102 @@
+import random
+from . import NetworkAgent
+
+
+class SentimentCorrelationModel(NetworkAgent):
+    """
+    Settings:
+        outside_effects_prob
+        
+        anger_prob
+        
+        joy_prob
+        
+        sadness_prob
+        
+        disgust_prob
+    """
+
+    def __init__(self, environment=None, agent_id=0, state=()):
+        super().__init__(environment=environment, agent_id=agent_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']
+        self.sadness_prob = environment.environment_params['sadness_prob']
+        self.disgust_prob = environment.environment_params['disgust_prob']
+        self.state['time_awareness'] = []
+        for i in range(4):  # In this model we have 4 sentiments
+            self.state['time_awareness'].append(0)  # 0-> Anger, 1-> joy, 2->sadness, 3 -> disgust
+        self.state['sentimentCorrelation'] = 0
+
+    def step(self):
+        self.behaviour()
+
+    def behaviour(self):
+
+        angry_neighbors_1_time_step = []
+        joyful_neighbors_1_time_step = []
+        sad_neighbors_1_time_step = []
+        disgusted_neighbors_1_time_step = []
+
+        angry_neighbors = self.get_neighboring_agents(state_id=1)
+        for x in angry_neighbors:
+            if x.state['time_awareness'][0] > (self.env.now-500):
+                angry_neighbors_1_time_step.append(x)
+        num_neighbors_angry = len(angry_neighbors_1_time_step)
+
+        joyful_neighbors = self.get_neighboring_agents(state_id=2)
+        for x in joyful_neighbors:
+            if x.state['time_awareness'][1] > (self.env.now-500):
+                joyful_neighbors_1_time_step.append(x)
+        num_neighbors_joyful = len(joyful_neighbors_1_time_step)
+
+        sad_neighbors = self.get_neighboring_agents(state_id=3)
+        for x in sad_neighbors:
+            if x.state['time_awareness'][2] > (self.env.now-500):
+                sad_neighbors_1_time_step.append(x)
+        num_neighbors_sad = len(sad_neighbors_1_time_step)
+
+        disgusted_neighbors = self.get_neighboring_agents(state_id=4)
+        for x in disgusted_neighbors:
+            if x.state['time_awareness'][3] > (self.env.now-500):
+                disgusted_neighbors_1_time_step.append(x)
+        num_neighbors_disgusted = len(disgusted_neighbors_1_time_step)
+
+        anger_prob = self.anger_prob+(len(angry_neighbors_1_time_step)*self.anger_prob)
+        joy_prob = self.joy_prob+(len(joyful_neighbors_1_time_step)*self.joy_prob)
+        sadness_prob = self.sadness_prob+(len(sad_neighbors_1_time_step)*self.sadness_prob)
+        disgust_prob = self.disgust_prob+(len(disgusted_neighbors_1_time_step)*self.disgust_prob)
+        outside_effects_prob = self.outside_effects_prob
+
+        num = random.random()
+
+        if num<outside_effects_prob:
+            self.state['id'] = random.randint(1, 4)
+
+            self.state['sentimentCorrelation'] = self.state['id'] # It is stored when it has been infected for the dynamic network
+            self.state['time_awareness'][self.state['id']-1] = self.env.now
+            self.state['sentiment'] = self.state['id']
+
+
+        if(num<anger_prob):
+
+            self.state['id'] = 1
+            self.state['sentimentCorrelation'] = 1
+            self.state['time_awareness'][self.state['id']-1] = self.env.now
+        elif (num<joy_prob+anger_prob and num>anger_prob):
+
+            self.state['id'] = 2
+            self.state['sentimentCorrelation'] = 2
+            self.state['time_awareness'][self.state['id']-1] = self.env.now
+        elif (num<sadness_prob+anger_prob+joy_prob and num>joy_prob+anger_prob):
+
+            self.state['id'] = 3
+            self.state['sentimentCorrelation'] = 3
+            self.state['time_awareness'][self.state['id']-1] = self.env.now
+        elif (num<disgust_prob+sadness_prob+anger_prob+joy_prob and num>sadness_prob+anger_prob+joy_prob):
+
+            self.state['id'] = 4
+            self.state['sentimentCorrelation'] = 4
+            self.state['time_awareness'][self.state['id']-1] = self.env.now
+
+        self.state['sentiment'] = self.state['id']

soil/agents/__init__.py

@@ -0,0 +1,166 @@
+# 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
+from collections import OrderedDict
+from copy import deepcopy
+import json
+
+from functools import wraps
+
+
+agent_types = {}
+
+
+class MetaAgent(type):
+    def __init__(cls, name, bases, nmspc):
+        super(MetaAgent, cls).__init__(name, bases, nmspc)
+        agent_types[name] = cls
+
+
+class BaseAgent(nxsim.BaseAgent, metaclass=MetaAgent):
+    """
+    A special simpy BaseAgent that keeps track of its state history.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self._history = OrderedDict()
+        self._neighbors = None
+        super().__init__(*args, **kwargs)
+
+    def __getitem__(self, key):
+        if isinstance(key, tuple):
+            k, t_step = key
+            if k is not None:
+                if t_step is not None:
+                    return self._history[t_step][k]
+                else:
+                    return {tt: tv.get(k, None) for tt, tv in self._history.items()}
+            else:
+                return self._history[t_step]
+        return self.state[key]
+
+    def __setitem__(self, key, value):
+        self.state[key] = value
+
+    def save_state(self):
+        self._history[self.now] = deepcopy(self.state)
+
+    @property
+    def now(self):
+        try:
+            return self.env.now
+        except AttributeError:
+            # No environment
+            return None
+
+    def run(self):
+        while True:
+            res = self.step()
+            yield res or self.env.timeout(self.env.interval)
+
+    def step(self):
+        pass
+
+    def to_json(self):
+        return json.dumps(self._history)
+
+
+class NetworkAgent(BaseAgent, nxsim.BaseNetworkAgent):
+
+    def count_agents(self, state_id=None, limit_neighbors=False):
+        if limit_neighbors:
+            agents = self.global_topology.neighbors(self.id)
+        else:
+            agents = self.global_topology.nodes()
+        count = 0
+        for agent in agents:
+            if state_id and state_id != self.global_topology.node[agent]['agent'].state['id']:
+                continue
+            count += 1
+        return count
+
+    def count_neighboring_agents(self, state_id=None):
+        return self.count_agents(state_id, limit_neighbors=True)
+
+
+def state(func):
+
+    @wraps(func)
+    def func_wrapper(self):
+        when = None
+        next_state = func(self)
+        try:
+            next_state, when = next_state
+        except TypeError:
+            pass
+        if next_state:
+            try:
+                self.state['id'] = next_state.id
+            except AttributeError:
+                raise NotImplemented('State id %s is not valid.' % next_state)
+        return when
+
+    func_wrapper.id = func.__name__
+    func_wrapper.is_default = False
+    return func_wrapper
+
+
+def default_state(func):
+    func.is_default = True
+    return func
+
+
+class MetaFSM(MetaAgent):
+    def __init__(cls, name, bases, nmspc):
+        super(MetaFSM, cls).__init__(name, bases, nmspc)
+        states = {}
+        # Re-use states from inherited classes
+        default_state = None
+        for i in bases:
+            if isinstance(i, MetaFSM):
+                for state_id, state in i.states.items():
+                    if state.is_default:
+                        default_state = state
+                    states[state_id] = state
+
+        # Add new states
+        for name, func in nmspc.items():
+            if hasattr(func, 'id'):
+                if func.is_default:
+                    default_state = func
+                states[func.id] = func
+        cls.default_state = default_state
+        cls.states = states
+
+
+class FSM(BaseAgent, metaclass=MetaFSM):
+    def __init__(self, *args, **kwargs):
+        super(FSM, self).__init__(*args, **kwargs)
+        if 'id' not in self.state:
+            self.state['id'] = self.default_state.id
+
+    def step(self):
+        if 'id' in self.state:
+            next_state = self.state['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))
+        self.states[next_state](self)
+
+
+from .BassModel import *
+from .BigMarketModel import *
+from .IndependentCascadeModel import *
+from .ModelM2 import *
+from .SentimentCorrelationModel import *
+from .SISaModel import *
+from .CounterModel import *
+from .DrawingAgent import *

soil/analysis.py

@@ -0,0 +1,23 @@
+import pandas as pd
+
+import glob
+import yaml
+from os.path import join
+
+
+def get_data(pattern, process=True, attributes=None):
+    for folder in glob.glob(pattern):
+        config_file = glob.glob(join(folder, '*.yml'))[0]
+        config = yaml.load(open(config_file))
+        for trial_data in sorted(glob.glob(join(folder, '*.environment.csv'))):
+            df = pd.read_csv(trial_data)
+            if process:
+                if attributes is not None:
+                    df = df[df['attribute'].isin(attributes)]
+                df = df.pivot_table(values='attribute', index='tstep', columns=['value'], aggfunc='count').fillna(0)
+            yield config_file, df, config
+
+
+def plot_all(*args, **kwargs):
+    for config_file, df, config in sorted(get_data(*args, **kwargs)):
+        df.plot(title=config['name'])

soil/environment.py

@@ -0,0 +1,190 @@
+import os
+import csv
+import weakref
+from random import random
+from copy import deepcopy
+
+import networkx as nx
+import nxsim
+
+
+class SoilEnvironment(nxsim.NetworkEnvironment):
+
+    def __init__(self, name=None,
+                 network_agents=None,
+                 environment_agents=None,
+                 states=None,
+                 default_state=None,
+                 interval=1,
+                 *args, **kwargs):
+        self.name = name or 'UnnamedEnvironment'
+        self.states = deepcopy(states) or {}
+        self.default_state = deepcopy(default_state) or {}
+        super().__init__(*args, **kwargs)
+        self._env_agents = {}
+        self._history = {}
+        self.interval = interval
+        self.logger = None
+        # 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.process(self.save_state())
+
+    @property
+    def agents(self):
+        yield from self.environment_agents
+        yield from self.network_agents
+
+    @property
+    def environment_agents(self):
+        for ref in self._env_agents.values():
+            yield ref()
+
+    @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(**kwargs,
+                      environment=self)
+            self._env_agents[a.id] = weakref.ref(a)
+
+    @property
+    def network_agents(self):
+        for i in self.G.nodes():
+            node = self.G.node[i]
+            if 'agent' in node:
+                yield node['agent']
+
+    @network_agents.setter
+    def network_agents(self, network_agents):
+        for ix in self.G.nodes():
+            i = ix
+            node = self.G.node[i]
+            v = random()
+            found = False
+            for d in network_agents:
+                threshold = d['threshold']
+                if v >= threshold[0] and v < threshold[1]:
+                    agent = d['agent_type']
+                    state = None
+                    if 'state' in d:
+                        state = deepcopy(d['state'])
+                    else:
+                        try:
+                            state = self.states[i]
+                        except (IndexError, KeyError):
+                            state = deepcopy(self.default_state)
+                    node['agent'] = agent(environment=self,
+                                          agent_id=i,
+                                          state=state)
+                    found = True
+                    break
+            assert found
+
+    def run(self, *args, **kwargs):
+        self._save_state()
+        super().run(*args, **kwargs)
+        self._save_state()
+
+    def _save_state(self):
+        for agent in self.agents:
+            agent.save_state()
+        self._history[self.now] = deepcopy(self.environment_params)
+
+    def save_state(self):
+        while True:
+            ev = self.event()
+            ev._ok = True
+            # Schedule the event with minimum priority so
+            # that it executes after all agents are done
+            self.schedule(ev, -1, self.interval)
+            yield ev
+            self._save_state()
+
+    def __getitem__(self, key):
+        return self.environment_params[key]
+
+    def __setitem__(self, key, value):
+        self.environment_params[key] = value
+
+    def get_path(self, dir_path=None):
+        dir_path = dir_path or self.sim().dir_path
+        if not os.path.exists(dir_path):
+            os.makedirs(dir_path)
+        return dir_path
+
+    def get_agent(self, agent_id):
+        return self.G.node[agent_id]['agent']
+
+    def get_agents(self):
+        return list(self.agents)
+
+    def dump_csv(self, dir_path=None):
+        csv_name = os.path.join(self.get_path(dir_path),
+                                '{}.environment.csv'.format(self.name))
+
+        with open(csv_name, 'w') as f:
+            cr = csv.writer(f)
+            cr.writerow(('agent_id', 'tstep', 'attribute', 'value'))
+            for i in self.history_to_tuples():
+                cr.writerow(i)
+
+    def dump_gexf(self, dir_path=None):
+        G = self.history_to_graph()
+        graph_path = os.path.join(self.get_path(dir_path),
+                                  self.name+".gexf")
+        nx.write_gexf(G, graph_path, version="1.2draft")
+
+    def history_to_tuples(self):
+        for tstep, state in self._history.items():
+            for attribute, value in state.items():
+                yield ('env', tstep, attribute, value)
+        for agent in self.agents:
+            for tstep, state in agent._history.items():
+                for attribute, value in state.items():
+                    yield (agent.id, tstep, attribute, value)
+
+    def history_to_graph(self):
+        G = nx.Graph(self.G)
+
+        for agent in self.agents:
+
+            attributes = {'agent': str(agent.__class__)}
+            lastattributes = {}
+            spells = []
+            lastvisible = False
+            laststep = None
+            for t_step, state in reversed(agent._history.items()):
+                for attribute, value in state.items():
+                    if attribute == 'visible':
+                        nowvisible = state[attribute]
+                        if nowvisible and not lastvisible:
+                            laststep = t_step
+                        if not nowvisible and lastvisible:
+                            spells.append((laststep, t_step))
+
+                        lastvisible = nowvisible
+                    else:
+                        if attribute not in lastattributes or lastattributes[attribute][0] != value:
+                            laststep = lastattributes.get(attribute,
+                                                          (None, None))[1]
+                            value = (state[attribute], t_step, laststep)
+                            key = 'attr_' + attribute
+                            if key not in attributes:
+                                attributes[key] = list()
+                            attributes[key].append(value)
+                            lastattributes[attribute] = (state[attribute], t_step)
+            if lastvisible:
+                spells.append((laststep, None))
+            if spells:
+                G.add_node(agent.id, attributes, spells=spells)
+            else:
+                G.add_node(agent.id, attributes)
+
+        return G

soil/settings.py

@@ -0,0 +1 @@
+# General configuration

soil/simulation.py

@@ -0,0 +1,241 @@
+import weakref
+import os
+import csv
+import time
+import yaml
+import networkx as nx
+from networkx.readwrite import json_graph
+
+from copy import deepcopy
+from random import random
+from matplotlib import pyplot as plt
+
+import pickle
+
+from nxsim import NetworkSimulation
+
+from . import agents, utils, environment, basestring
+
+
+class SoilSimulation(NetworkSimulation):
+    """
+    Subclass of nsim.NetworkSimulation with three main differences:
+        1) agent type can be specified by name or by class.
+        2) instead of just one type, an network_agents can be used.
+           The distribution specifies the weight (or probability) of each
+           agent type in the topology. This is an example distribution: ::
+
+                  [
+                    {'agent_type': 'agent_type_1',
+                     'weight': 0.2,
+                     'state': {
+                         'id': 0
+                      }
+                    },
+                    {'agent_type': 'agent_type_2',
+                     'weight': 0.8,
+                     'state': {
+                         'id': 1
+                      }
+                    }
+                  ]
+
+          In this example, 20% of the nodes will be marked as type
+          'agent_type_1'.
+        3) if no initial state is given, each node's state will be set
+           to `{'id': 0}`.
+    """
+    def __init__(self, name=None, topology=None, network_params=None,
+                 network_agents=None, agent_type=None, states=None,
+                 default_state=None, interval=1,
+                 dir_path=None, num_trials=3, max_time=100,
+                 agent_module=None,
+                 environment_agents=None, environment_params=None):
+
+        if topology is None:
+            topology = utils.load_network(network_params,
+                                          dir_path=dir_path)
+        elif isinstance(topology, basestring) or isinstance(topology, dict):
+            topology = json_graph.node_link_graph(topology)
+
+        self.topology = nx.Graph(topology)
+        self.network_params = network_params
+        self.name = name or 'UnnamedSimulation'
+        self.num_trials = num_trials
+        self.max_time = max_time
+        self.default_state = default_state or {}
+        self.dir_path = dir_path or os.getcwd()
+        self.interval = interval
+        self.environment_params = environment_params or {}
+
+        environment_agents = environment_agents or []
+        self.environment_agents = self._convert_agent_types(environment_agents)
+
+        distro = self.calculate_distribution(network_agents,
+                                             agent_type)
+        self.network_agents = self._convert_agent_types(distro)
+
+        self.states = self.validate_states(states,
+                                           topology)
+
+    def calculate_distribution(self,
+                               network_agents=None,
+                               agent_type=None):
+        if network_agents:
+            network_agents = deepcopy(network_agents)
+        elif agent_type:
+            network_agents = [{'agent_type': agent_type}]
+        else:
+            return []
+
+        # Calculate the thresholds
+        total = sum(x.get('weight', 1) for x in network_agents)
+        acc = 0
+        for v in network_agents:
+            upper = acc + (v.get('weight', 1)/total)
+            v['threshold'] = [acc, upper]
+            acc = upper
+        return network_agents
+
+    def serialize_distribution(self):
+        d = self._convert_agent_types(self.network_agents,
+                                      to_string=True)
+        for v in d:
+            if 'threshold' in v:
+                del v['threshold']
+        return d
+
+    def _convert_agent_types(self, ind, to_string=False):
+        d = deepcopy(ind)
+        for v in d:
+            agent_type = v['agent_type']
+            if to_string and not isinstance(agent_type, str):
+                v['agent_type'] = str(agent_type.__name__)
+            elif not to_string and isinstance(agent_type, str):
+                v['agent_type'] = agents.agent_types[agent_type]
+        return d
+
+    def validate_states(self, states, topology):
+        states = states or []
+        # Validate states to avoid ignoring states during
+        # initialization
+        if isinstance(states, dict):
+            for x in states:
+                assert x in self.topology.node
+        else:
+            assert len(states) <= len(self.topology)
+        return states
+
+    def run_simulation(self):
+        return self.run()
+
+    def run(self):
+        return list(self.run_simulation_gen())
+
+    def run_simulation_gen(self):
+        with utils.timer('simulation'):
+            for i in range(self.num_trials):
+                yield self.run_trial(i)
+
+    def run_trial(self, trial_id=0):
+        """Run a single trial of the simulation
+
+        Parameters
+        ----------
+        trial_id : int
+        """
+        # Set-up trial environment and graph
+        print('Trial: {}'.format(trial_id))
+        env_name = '{}_trial_{}'.format(self.name, trial_id)
+        env = environment.SoilEnvironment(name=env_name,
+                                          topology=self.topology.copy(),
+                                          initial_time=0,
+                                          interval=self.interval,
+                                          network_agents=self.network_agents,
+                                          states=self.states,
+                                          default_state=self.default_state,
+                                          environment_agents=self.environment_agents,
+                                          **self.environment_params)
+
+        env.sim = weakref.ref(self)
+        # Set up agents on nodes
+        print('\tRunning')
+        with utils.timer('trial'):
+            env.run(until=self.max_time)
+        return env
+
+    def to_dict(self):
+        return self.__getstate__()
+
+    def to_yaml(self):
+        return yaml.dump(self.to_dict())
+
+    def dump_yaml(self, dir_path=None, file_name=None):
+        dir_path = dir_path or self.dir_path
+        if not os.path.exists(dir_path):
+            os.makedirs(dir_path)
+        if not file_name:
+            file_name = os.path.join(dir_path,
+                                     '{}.dumped.yml'.format(self.name))
+        with open(file_name, 'w') as f:
+            f.write(self.to_yaml())
+
+    def dump_pickle(self, dir_path=None, pickle_name=None):
+        dir_path = dir_path or self.dir_path
+        if not os.path.exists(dir_path):
+            os.makedirs(dir_path)
+        if not pickle_name:
+            pickle_name = os.path.join(dir_path,
+                                       '{}.simulation.pickle'.format(self.name))
+        with open(pickle_name, 'wb') as f:
+            pickle.dump(self, f)
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state['topology'] = json_graph.node_link_data(self.topology)
+        state['network_agents'] = self.serialize_distribution()
+        state['environment_agents'] = self._convert_agent_types(self.environment_agents,
+                                                          to_string=True)
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+        self.topology = json_graph.node_link_graph(state['topology'])
+        self.network_agents = self._convert_agent_types(self.network_agents)
+        self.environment_agents = self._convert_agent_types(self.environment_agents)
+        return state
+
+
+def from_config(config, G=None):
+    config = list(utils.load_config(config))
+    if len(config) > 1:
+        raise AttributeError('Provide only one configuration')
+    config = config[0][0]
+    sim = SoilSimulation(**config)
+    return sim
+
+
+def run_from_config(*configs, dump=True, results_dir=None, timestamp=False):
+    if not results_dir:
+        results_dir = 'soil_output'
+    for config_def in configs:
+        for config, cpath in utils.load_config(config_def):
+            name = config.get('name', 'unnamed')
+            print("Using config(s): {name}".format(name=name))
+
+            sim = SoilSimulation(**config)
+            if timestamp:
+                sim_folder = '{}_{}'.format(sim.name,
+                                            time.strftime("%Y-%m-%d_%H:%M:%S"))
+            else:
+                sim_folder = sim.name
+            dir_path = os.path.join(results_dir,
+                                    sim_folder)
+            results = sim.run_simulation()
+
+            if dump:
+                sim.dump_pickle(dir_path)
+                sim.dump_yaml(dir_path)
+                for env in results:
+                    env.dump_gexf(dir_path)
+                    env.dump_csv(dir_path)

soil/utils.py

@@ -0,0 +1,61 @@
+import os
+import yaml
+from time import time
+from glob import glob
+
+import networkx as nx
+
+from contextlib import contextmanager
+
+
+def load_network(network_params, dir_path=None):
+    path = network_params.get('path', None)
+    if path:
+        if dir_path and not os.path.isabs(path):
+            path = os.path.join(dir_path, path)
+        extension = os.path.splitext(path)[1][1:]
+        kwargs = {}
+        if extension == 'gexf':
+            kwargs['version'] = '1.2draft'
+            kwargs['node_type'] = int
+        try:
+            method = getattr(nx.readwrite, 'read_' + extension)
+        except AttributeError:
+            raise AttributeError('Unknown format')
+        return method(path, **kwargs)
+
+    net_args = network_params.copy()
+    net_type = net_args.pop('generator')
+
+    method = getattr(nx.generators, net_type)
+    return method(**net_args)
+
+
+def load_file(infile):
+    with open(infile, 'r') as f:
+        return list(yaml.load_all(f))
+
+
+def load_files(*patterns):
+    for pattern in patterns:
+        for i in glob(pattern):
+            for config in load_file(i):
+                yield config, os.path.abspath(i)
+
+
+def load_config(config):
+    if isinstance(config, dict):
+        yield config, None
+    else:
+        yield from load_files(config)
+
+
+@contextmanager
+def timer(name='task', pre="", function=print, to_object=None):
+    start = time()
+    yield start
+    end = time()
+    function('{}Finished {} in {} seconds'.format(pre, name, str(end-start)))
+    if to_object:
+        to_object.start = start
+        to_object.end = end