docs: def _process_download_descriptor(self, dd):
          # type: (Downloader, blobxfer.models.download.Descriptor) -> None
          """Process download descriptor
          :param Downloader self: this
          :param blobxfer.models.download.Descriptor dd: download descriptor
          """
          # update progress bar
          self._update_progress_bar()
          # get download offsets
          offsets, resume_bytes = dd.next_offsets()
          # add resume bytes to counter
          if resume_bytes is not None:
              with self._disk_operation_lock:
                  self._download_bytes_sofar += resume_bytes
                  logger.debug('adding {} sofar {} from {}'.format(
                      resume_bytes, self._download_bytes_sofar, dd.entity.name))
              del resume_bytes
          # check if all operations completed
          if offsets is None and dd.all_operations_completed:
              finalize = True
              sfpath = str(dd.final_path)
              # finalize integrity
              dd.finalize_integrity()
              # vectored io checks
              if dd.entity.vectored_io is not None:
                  with self._transfer_lock:
                      if sfpath not in self._vio_map:
                          self._vio_map[sfpath] = 1
                      else:
                          self._vio_map[sfpath] += 1
                      if (self._vio_map[sfpath] ==
                              dd.entity.vectored_io.total_slices):
                          self._vio_map.pop(sfpath)
                      else:
                          finalize = False
              # finalize file
              if finalize:
                  dd.finalize_file()
              # accounting
              with self._transfer_lock:
                  self._download_sofar += 1
                  if dd.entity.is_encrypted:
                      self._dd_map.pop(sfpath)
                  self._transfer_set.remove(
                      blobxfer.operations.download.Downloader.
                      create_unique_transfer_operation_id(dd.entity))
                  self._transfer_cc.pop(dd.entity.path, None)
              return
          # re-enqueue for other threads to download
          if offsets is None:
              self._transfer_queue.put(dd)
              return
          # ensure forthcoming disk operation is accounted for
          with self._disk_operation_lock:
              self._disk_set.add(
                  blobxfer.operations.download.Downloader.
                  create_unique_disk_operation_id(dd, offsets))
          # check if there are too many concurrent connections
          with self._transfer_lock:
              self._transfer_cc[dd.entity.path] += 1
              cc_xfer = self._transfer_cc[dd.entity.path]
          if cc_xfer <= self._spec.options.max_single_object_concurrency:
              self._transfer_queue.put(dd)
          # issue get range
          if dd.entity.mode == blobxfer.models.azure.StorageModes.File:
              data = blobxfer.operations.azure.file.get_file_range(
                  dd.entity, offsets)
          else:
              data = blobxfer.operations.azure.blob.get_blob_range(
                  dd.entity, offsets)
          with self._transfer_lock:
              self._transfer_cc[dd.entity.path] -= 1
          if cc_xfer > self._spec.options.max_single_object_concurrency:
              self._transfer_queue.put(dd)
          # enqueue data for processing
          self._disk_queue.put((dd, offsets, data))