code: def timeout_process_add_queue(self, module, cache_time):
          
          # If already set to update do nothing
          if module in self.timeout_update_due:
              return
  
          # remove if already in the queue
          key = self.timeout_queue_lookup.get(module)
          if key:
              queue_item = self.timeout_queue[key]
              queue_item.remove(module)
              if not queue_item:
                  del self.timeout_queue[key]
                  self.timeout_keys.remove(key)
  
          if cache_time == 0:
              # if cache_time is 0 we can just trigger the module update
              self.timeout_update_due.append(module)
              self.timeout_queue_lookup[module] = None
          else:
              # add the module to the timeout queue
              if cache_time not in self.timeout_keys:
                  self.timeout_queue[cache_time] = set([module])
                  self.timeout_keys.append(cache_time)
                  # sort keys so earliest is first
                  self.timeout_keys.sort()
  
                  # when is next timeout due?
                  try:
                      self.timeout_due = self.timeout_keys[0]
                  except IndexError:
                      self.timeout_due = None
              else:
                  self.timeout_queue[cache_time].add(module)
              # note that the module is in the timeout_queue
              self.timeout_queue_lookup[module] = cache_time
docs: Add a module to the timeout_queue if it is scheduled in the future or
          if it is due for an update immediately just trigger that.
  
          the timeout_queue is a dict with the scheduled time as the key and the
          value is a list of module instance names due to be updated at that
          point. An ordered list of keys is kept to allow easy checking of when
          updates are due.  A list is also kept of which modules are in the
          update_queue to save having to search for modules in it unless needed.