docs: def _start(self, items):
          """ Start some items if conditions are met.
          """
          # TODO: Filter by a custom date field, for scheduled downloads starting at a certain time, or after a given delay
  
          # TODO: Don't start anything more if download BW is used >= config threshold in %
  
          # Check if anything more is ready to start downloading
          startable = [i for i in items if self.config.startable.match(i)]
          if not startable:
              self.LOG.debug("Checked %d item(s), none startable according to [ %s ]",
                             len(items), self.config.startable)
              return
  
          # Check intermission delay
          now = time.time()
          if now < self.last_start:
              # compensate for summer time and other oddities
              self.last_start = now
          delayed = int(self.last_start + self.config.intermission - now)
          if delayed > 0:
              self.LOG.debug("Delaying start of {:d} item(s),"
                             " due to {:d}s intermission with {:d}s left"
                             .format(len(startable), self.config.intermission, delayed))
              return
  
          # TODO: sort by priority, then loaded time
  
          # Stick to "start_at_once" parameter, unless "downloading_min" is violated
          downloading = [i for i in items if self.config.downloading.match(i)]
          start_now = max(self.config.start_at_once, self.config.downloading_min - len(downloading))
          start_now = min(start_now, len(startable))
  
          #down_traffic = sum(i.down for i in downloading)
          ##self.LOG.info("%d downloading, down %d" % (len(downloading), down_traffic))
  
          # Start eligible items
          for idx, item in enumerate(startable):
              # Check if we reached 'start_now' in this run
              if idx >= start_now:
                  self.LOG.debug("Only starting %d item(s) in this run, %d more could be downloading" % (
                      start_now, len(startable)-idx,))
                  break
  
              # TODO: Prevent start of more torrents that can fit on the drive (taking "off" files into account)
              # (restarts items that were stopped due to the "low_diskspace" schedule, and also avoids triggering it at all)
  
              # Only check the other conditions when we have `downloading_min` covered
              if len(downloading) < self.config.downloading_min:
                  self.LOG.debug("Catching up from %d to a minimum of %d downloading item(s)" % (
                      len(downloading), self.config.downloading_min))
              else:
                  # Limit to the given maximum of downloading items
                  if len(downloading) >= self.config.downloading_max:
                      self.LOG.debug("Already downloading %d item(s) out of %d max, %d more could be downloading" % (
                          len(downloading), self.config.downloading_max, len(startable)-idx,))
                      break
  
              # If we made it here, start it!
              self.last_start = now
              downloading.append(item)
              self.LOG.info("%s '%s' [%s, #%s]" % (
                  "WOULD start" if self.config.dry_run else "Starting",
                  fmt.to_utf8(item.name), item.alias, item.hash))
              if not self.config.dry_run:
                  item.start()
                  if not self.config.quiet:
                      self.proxy.log(xmlrpc.NOHASH, "%s: Started '%s' {%s}" % (
                          self.__class__.__name__, fmt.to_utf8(item.name), item.alias,
                      ))