docs: def to_dask_dataframe(self, dim_order=None, set_index=False):
          """
          Convert this dataset into a dask.dataframe.DataFrame.
  
          The dimensions, coordinates and data variables in this dataset form
          the columns of the DataFrame.
  
          Parameters
          ----------
          dim_order : list, optional
              Hierarchical dimension order for the resulting dataframe. All
              arrays are transposed to this order and then written out as flat
              vectors in contiguous order, so the last dimension in this list
              will be contiguous in the resulting DataFrame. This has a major
              influence on which operations are efficient on the resulting dask
              dataframe.
  
              If provided, must include all dimensions on this dataset. By
              default, dimensions are sorted alphabetically.
          set_index : bool, optional
              If set_index=True, the dask DataFrame is indexed by this dataset's
              coordinate. Since dask DataFrames to not support multi-indexes,
              set_index only works if the dataset only contains one dimension.
  
          Returns
          -------
          dask.dataframe.DataFrame
          """
  
          import dask.array as da
          import dask.dataframe as dd
  
          if dim_order is None:
              dim_order = list(self.dims)
          elif set(dim_order) != set(self.dims):
              raise ValueError(
                  'dim_order {} does not match the set of dimensions on this '
                  'Dataset: {}'.format(dim_order, list(self.dims)))
  
          ordered_dims = OrderedDict((k, self.dims[k]) for k in dim_order)
  
          columns = list(ordered_dims)
          columns.extend(k for k in self.coords if k not in self.dims)
          columns.extend(self.data_vars)
  
          series_list = []
          for name in columns:
              try:
                  var = self.variables[name]
              except KeyError:
                  # dimension without a matching coordinate
                  size = self.dims[name]
                  data = da.arange(size, chunks=size, dtype=np.int64)
                  var = Variable((name,), data)
  
              # IndexVariable objects have a dummy .chunk() method
              if isinstance(var, IndexVariable):
                  var = var.to_base_variable()
  
              dask_array = var.set_dims(ordered_dims).chunk(self.chunks).data
              series = dd.from_array(dask_array.reshape(-1), columns=[name])
              series_list.append(series)
  
          df = dd.concat(series_list, axis=1)
  
          if set_index:
              if len(dim_order) == 1:
                  (dim,) = dim_order
                  df = df.set_index(dim)
              else:
                  # triggers an error about multi-indexes, even if only one
                  # dimension is passed
                  df = df.set_index(dim_order)
  
          return df