docs: def apply_async(self, args, kwargs, **options):
          """
          Put this task on the Celery queue as a singleton. Only one of this type
          of task with its distinguishing args/kwargs will be allowed on the
          queue at a time. Subsequent duplicate tasks called while this task is
          still running will just latch on to the results of the running task by
          synchronizing the task uuid. Additionally, identical task calls will
          return those results for the next ``cache_duration`` seconds.
          """
          self._validate_required_class_vars()
  
          cache_key = self._get_cache_key(**kwargs)
  
          # Check for an already-computed and cached result
          task_id = self.cache.get(cache_key)  # Check for the cached result
          if task_id:
              # We've already built this result, just latch on to the task that
              # did the work
              logging.info(
                  'Found existing cached and completed task: %s', task_id)
              return self.AsyncResult(task_id)
  
          # Check for an in-progress equivalent task to avoid duplicating work
          task_id = self.cache.get('herd:%s' % cache_key)
          if task_id:
              logging.info('Found existing in-progress task: %s', task_id)
              return self.AsyncResult(task_id)
  
          # It's not cached and it's not already running. Use an atomic lock to
          # start the task, ensuring there isn't a race condition that could
          # result in multiple identical tasks being fired at once.
          with self.cache.lock('lock:%s' % cache_key):
              task_meta = super(JobtasticTask, self).apply_async(
                  args,
                  kwargs,
                  **options
              )
              logging.info('Current status: %s', task_meta.status)
              if task_meta.status in (PROGRESS, PENDING):
                  self.cache.set(
                      'herd:%s' % cache_key,
                      task_meta.task_id,
                      timeout=self.herd_avoidance_timeout)
                  logging.info(
                      'Setting herd-avoidance cache for task: %s', cache_key)
          return task_meta