code: def _do_download_file(self, dss_file, fh, num_retries, min_delay_seconds):
          hasher = hashlib.sha256()
          delay = min_delay_seconds
          retries_left = num_retries
          while True:
              try:
                  response = self.get_file._request(
                      dict(uuid=dss_file.uuid, version=dss_file.version, replica=dss_file.replica),
                      stream=True,
                      headers={
                          'Range': "bytes={}-".format(fh.tell())
                      },
                  )
                  try:
                      if not response.ok:
                          logger.error("%s", "File {}: GET FAILED.".format(dss_file.uuid))
                          logger.error("%s", "Response: {}".format(response.text))
                          break
                      consume_bytes = int(fh.tell())
                      server_start = 0
                      content_range_header = response.headers.get('Content-Range', None)
                      if content_range_header is not None:
                          cre = re.compile("bytes (\d+)-(\d+)")
                          mo = cre.search(content_range_header)
                          if mo is not None:
                              server_start = int(mo.group(1))
                      consume_bytes -= server_start
                      assert consume_bytes >= 0
                      if server_start > 0 and consume_bytes == 0:
                          logger.info("%s", "File {}: Resuming at {}.".format(
                              dss_file.uuid, server_start))
                      elif consume_bytes > 0:
                          logger.info("%s", "File {}: Resuming at {}. Dropping {} bytes to match".format(
                              dss_file.uuid, server_start, consume_bytes))
                          while consume_bytes > 0:
                              bytes_to_read = min(consume_bytes, 1024*1024)
                              content = response.iter_content(chunk_size=bytes_to_read)
                              chunk = next(content)
                              if chunk:
                                  consume_bytes -= len(chunk)
                      for chunk in response.iter_content(chunk_size=1024*1024):
                          if chunk:
                              fh.write(chunk)
                              hasher.update(chunk)
                              retries_left = min(retries_left + 1, num_retries)
                              delay = max(delay / 2, min_delay_seconds)
                      break
                  finally:
                      response.close()
              except (ChunkedEncodingError, ConnectionError, ReadTimeout):
                  if retries_left > 0:
                      logger.info("%s", "File {}: GET FAILED. Attempting to resume.".format(dss_file.uuid))
                      time.sleep(delay)
                      delay *= 2
                      retries_left -= 1
                      continue
                  raise
          return hasher.hexdigest()