code: def download_from_cvat(self, max_retry_count=5, retry_wait_time=10):
      status = self.task_status()
      if status != "completed":
          logger.info(
              f"No Tasks with completed status (current: {status}) to refresh/download the final labels"
          )
          return None
  
      project_id = self.get_cvat_project_id(create=False)
      task_id, task_name = self.get_cvat_task_id(
          project_id, create=False
      )
      logger.info(
          f"Preparing to download/update final labels from: {project_id} => {task_id} => {task_name}"
      )
  
      download_url = f"{self.api_url}/api/tasks/{task_id}/annotations?action=download&format=Segmentation+mask+1.1"
      tmp_folder = tempfile.TemporaryDirectory().name
      os.makedirs(tmp_folder, exist_ok=True)
  
      tmp_zip = tempfile.NamedTemporaryFile(suffix=".zip").name
      retry_count = 0
      for retry in range(max_retry_count):
          try:
              r = requests.get(
                  download_url, allow_redirects=True, auth=self.auth
              )
              time.sleep(retry_wait_time)
  
              with open(tmp_zip, "wb") as fp:
                  fp.write(r.content)
              shutil.unpack_archive(tmp_zip, tmp_folder)
  
              segmentations_dir = os.path.join(
                  tmp_folder, "SegmentationClass"
              )
              final_labels = self._datastore.label_path(
                  DefaultLabelTag.FINAL
              )
              for f in os.listdir(segmentations_dir):
                  label = os.path.join(segmentations_dir, f)
                  if os.path.isfile(label) and label.endswith(".png"):
                      os.makedirs(final_labels, exist_ok=True)
  
                      dest = os.path.join(final_labels, f)
                      if self.normalize_label:
                          img = np.array(Image.open(label))
                          mask = np.zeros_like(img)
  
                          labelmap = self._load_labelmap_txt(
                              os.path.join(tmp_folder, "labelmap.txt")
                          )
                          for name, color in labelmap.items():
                              if name in self.label_map:
                                  idx = self.label_map.get(name)
                                  mask[
                                      np.all(img == color, axis=-1)
                                  ] = idx
                          Image.fromarray(mask[:, :, 0]).save(
                              dest
                          )  # single channel
                          logger.info(
                              f"Copy Final Label: {label} to {dest}; unique: {np.unique(mask)}"
                          )
                      else:
                          Image.open(label).save(dest)
                          logger.info(
                              f"Copy Final Label: {label} to {dest}"
                          )
  
              # Rename after consuming/downloading the labels
              patch_url = f"{self.api_url}/api/tasks/{task_id}"
              body = {"name": f"{self.done_prefix}_{task_name}"}
              requests.patch(
                  patch_url,
                  allow_redirects=True,
                  auth=self.auth,
                  json=body,
              )
              return task_name
          except Exception as e:
              if retry_count:
                  logger.exception(e)
              logger.error(f"{retry} => Failed to download...")
          retry_count = retry_count + 1
      return None
  
imports: import json
  import logging
  import os
  import shutil
  import tempfile
  import time
  import urllib.parse
  import numpy
  import requests
  from PIL import Image
  from requests.auth import HTTPBasicAuth
  from monailabel.datastore.local import LocalDatastore
  from monailabel.interfaces.datastore import DefaultLabelTag
  from monailabel.utils.others.generic import get_mime_type
label_desc: Use image node_id 10 for calling the CVATDatastore obj's underlying member method code with example usage: obj.download_from_cvat(max_retry_count, retry_wait_time) and returns: None, None, task_name