class_docstr: Interface to submit and collect a job in a distributed fashion. DaskParallelRunner is
  intended to comply with the bridge design pattern. Nevertheless, to reduce the amount of code
  within single-vs-parallel implementations, DaskParallelRunner wraps a BaseRunner object which
  is then executed in parallel on `n_workers`.
  
  This class then is constructed by passing an AbstractRunner that implements
  a `run` method, and is capable of doing so in a serial fashion. Next,
  this wrapper class uses dask to initialize `N` number of AbstractRunner that actively wait of a
  TrialInfo to produce a RunInfo object.
  
  To be more precise, the work model is then:
  
  1. The intensifier dictates "what" to run (a configuration/instance/seed) via a TrialInfo object.
  2. An abstract runner takes this TrialInfo object and launches the task via
     `submit_run`. In the case of DaskParallelRunner, `n_workers` receive a pickle-object of
     `DaskParallelRunner.single_worker`, each with a `run` method coming from
     `DaskParallelRunner.single_worker.run()`
  3. TrialInfo objects are run in a distributed fashion, and their results are available locally to each worker. The
     result is collected by `iter_results` and then passed to SMBO.
  4. Exceptions are also locally available to each worker and need to be collected.
  
  Dask works with `Future` object which are managed via the DaskParallelRunner.client.
  
  Parameters
  ----------
  single_worker : AbstractRunner
      A runner to run in a distributed fashion. Will be distributed using `n_workers`.
  patience: int, default to 5
      How much to wait for workers (seconds) to be available if one fails.
  dask_client: Client | None, defaults to None
      User-created dask client, which can be used to start a dask cluster and then attach SMAC to it. This will not
      be closed automatically and will have to be closed manually if provided explicitly. If none is provided
      (default), a local one will be created for you and closed upon completion.
code: def is_running(self) -> bool:  # noqa: D102
      return len(self._pending_trials) > 0
  
imports: from __future__ import annotations
  from typing import Any, Iterator
  import time
  from pathlib import Path
  import dask
  from ConfigSpace import Configuration
  from dask.distributed import Client, Future, wait
  from smac.runhistory import StatusType, TrialInfo, TrialValue
  from smac.runner.abstract_runner import AbstractRunner
  from smac.utils.logging import get_logger
label_desc: Use image node_id 5 for calling the DaskParallelRunner obj's underlying member method code with example usage: obj.is_running() and returns: unknown