code: def check_streamers(self, blacklist=None):
          
  
          ready = []
          selected = set()
  
          for i, streamer in enumerate(self.streamers):
              if blacklist is not None and i in blacklist:
                  continue
  
              if i in selected:
                  continue
  
              marked = False
              if i in self._manually_triggered_streamers:
                  marked = True
                  self._manually_triggered_streamers.remove(i)
  
              if streamer.triggered(marked):
                  self._logger.debug("Streamer %d triggered, manual=%s", i, marked)
                  ready.append(streamer)
                  selected.add(i)
  
                  # Handle streamers triggered with another
                  for j, streamer2 in enumerate(self.streamers[i:]):
                      if streamer2.with_other == i and j not in selected and streamer2.triggered(True):
                          self._logger.debug("Streamer %d triggered due to with-other on %d", j, i)
                          ready.append(streamer2)
                          selected.add(j)
  
          return ready
docs: Check if any streamers are ready to produce a report.
  
          You can limit what streamers are checked by passing a set-like
          object into blacklist.
  
          This method is the primary way to see when you should poll a given
          streamer for its next report.
  
          Note, this function is not idempotent.  If a streamer is marked as
          manual and it is triggered from a node rule inside the sensor_graph,
          that trigger will only last as long as the next call to
          check_streamers() so you need to explicitly build a report on all
          ready streamers before calling check_streamers again.
  
          Args:
              blacklist (set): Optional set of streamer indices that should
                  not be checked right now.
  
          Returns:
              list of DataStreamer: A list of the ready streamers.