code: def _resolve_path_load(self, cdx, is_original, failed_files):
          
  
          if is_original:
              (filename, offset, length) = (cdx['orig.filename'],
                                            cdx['orig.offset'],
                                            cdx['orig.length'])
          else:
              (filename, offset, length) = (cdx['filename'],
                                            cdx['offset'],
                                            cdx.get('length', '-'))
  
          # optimization: if same file already failed this request,
          # don't try again
          if failed_files is not None and filename in failed_files:
              raise ArchiveLoadFailed('Skipping Already Failed: ' + filename)
  
          any_found = False
          last_exc = None
          last_traceback = None
          for resolver in self.path_resolvers:
              possible_paths = resolver(filename, cdx)
  
              if not possible_paths:
                  continue
  
              if isinstance(possible_paths, six.string_types):
                  possible_paths = [possible_paths]
  
              for path in possible_paths:
                  any_found = True
                  try:
                      return (self.record_loader.
                               load(path, offset, length,
                                 no_record_parse=self.no_record_parse))
  
                  except Exception as ue:
                      last_exc = ue
                      import sys
                      last_traceback = sys.exc_info()[2]
  
          # Unsuccessful if reached here
          if failed_files is not None:
              failed_files.append(filename)
  
          if last_exc:
              #msg = str(last_exc.__class__.__name__)
              msg = str(last_exc)
          else:
              msg = 'Archive File Not Found'
  
          #raise ArchiveLoadFailed(msg, filename), None, last_traceback
          six.reraise(ArchiveLoadFailed, ArchiveLoadFailed(filename + ': ' + msg), last_traceback)
docs: Load specific record based on filename, offset and length
          fields in the cdx.
          If original=True, use the orig.* fields for the cdx
  
          Resolve the filename to full path using specified path resolvers
  
          If failed_files list provided, keep track of failed resolve attempts