code: def _temporal_split_list(self,numSubLists):
          
          # Assume segment lists are coalesced!
          startTime = float( min([i.segment_list[0][0] for i in self]))
          endTime = float( max([i.segment_list[-1][-1] for i in self]))
          step = (endTime - startTime) / float(numSubLists)
  
          # Set up storage
          self._splitLists = []
          for idx in range(numSubLists):
              self._splitLists.append(FileList([]))
  
          # Sort the files
  
          for currFile in self:
              segExtent = currFile.segment_list.extent()
              startIdx = (segExtent[0] - startTime) / step
              endIdx = (segExtent[1] - startTime) / step
              # Add some small rounding here
              startIdx = int(startIdx - 0.001)
              endIdx = int(endIdx + 0.001)
  
              if startIdx < 0:
                  startIdx = 0
              if endIdx >= numSubLists:
                  endIdx = numSubLists - 1
  
              for idx in range(startIdx, endIdx + 1):
                  self._splitLists[idx].append(currFile)
  
          # Set information needed to detect changes and to be used elsewhere
          self._splitListsLength = len(self)
          self._splitListsNum = numSubLists
          self._splitListsStart = startTime
          self._splitListsEnd = endTime
          self._splitListsStep = step
          self._splitListsSet = True
docs: This internal function is used to speed the code up in cases where a
          number of operations are being made to determine if files overlap a
          specific time. Normally such operations are done on *all* entries with
          *every* call. However, if we predetermine which files are at which
          times, we can avoid testing *every* file every time.
  
          We therefore create numSubLists distinct and equal length time windows
          equally spaced from the first time entry in the list until the last.
          A list is made for each window and files are added to lists which they
          overlap.
  
          If the list changes it should be captured and these split lists become
          invalid. Currently the testing for this is pretty basic