docs: def iteration(self, node_status=True):
          """
          Execute a single model iteration
          :return: Iteration_id, Incremental node status (dictionary node->status)
          """
          self.clean_initial_status(self.available_statuses.values())
  
          actual_status = {node: nstatus for node, nstatus in future.utils.iteritems(self.status)}
  
          if self.actual_iteration == 0:
              self.actual_iteration += 1
              self.params['model']['queue'] = dict()
              return 0, actual_status
  
          gamma = float(self.params['model']['mu']) * float(self.actual_iteration) / float(self.params['model']['tau'])
          list_node = self.graph.nodes()
          start = min(list_node)
          stop = max(list_node)
          number_node_susceptible = len(self.graph.nodes()) - sum(self.status.values())
  
          while gamma >= 1 and number_node_susceptible >= 1:
              random_index = random.randrange(start, stop+1, 1)
              if random_index in list_node and actual_status[random_index] == 0:
                  actual_status[random_index] = 1
                  gamma -= 1
                  number_node_susceptible -= 1
  
          for u in self.graph.nodes():
              if actual_status[u] == 1:
                  continue
  
              neighbors = list(self.graph.neighbors(u))
              if isinstance(self.graph, nx.DiGraph):
                  neighbors = list(self.graph.predecessors(u))
  
              infected = 0
              for v in neighbors:
                  infected += self.status[v]
  
              if len(neighbors) > 0:
                  infected_ratio = float(infected)/len(neighbors)
                  if infected_ratio >= self.params['nodes']['threshold'][u]:
                      if u not in self.inqueue:
                          self.queue.put((self.actual_iteration, u))
                          self.inqueue[u] = None
  
          while not self.queue.empty():
              next = self.queue.queue[0]
              if self.actual_iteration - next[0] >= self.params['model']['tau']:
                  self.queue.get()
              else:
                  break
  
          delta = self.status_delta(actual_status)
          self.status = actual_status
          self.actual_iteration += 1
  
          return self.actual_iteration - 1, delta