class_docstr: The DaskInterface allows a Dataset objects to wrap a dask
  DataFrame object. Using dask allows loading data lazily
  and performing out-of-core operations on the data, making
  it possible to work on datasets larger than memory.
  
  The DaskInterface covers almost the complete API exposed
  by the PandasInterface with two notable exceptions:
  
  1) Sorting is not supported and any attempt at sorting will
     be ignored with an warning.
  2) Dask does not easily support adding a new column to an existing
     dataframe unless it is a scalar, add_dimension will therefore
     error when supplied a non-scalar value.
  4) Not all functions can be easily applied to a dask dataframe so
     some functions applied with aggregate and reduce will not work.
code: def groupby(
      cls, dataset, dimensions, container_type, group_type, **kwargs
  ):
      index_dims = [dataset.get_dimension(d) for d in dimensions]
      element_dims = [
          kdim for kdim in dataset.kdims if kdim not in index_dims
      ]
  
      group_kwargs = {}
      if group_type != "raw" and issubclass(group_type, Element):
          group_kwargs = dict(
              util.get_param_values(dataset), kdims=element_dims
          )
      group_kwargs.update(kwargs)
  
      # Propagate dataset
      group_kwargs["dataset"] = dataset.dataset
  
      data = []
      group_by = [d.name for d in index_dims]
      groupby = dataset.data.groupby(group_by)
      if len(group_by) == 1:
          column = dataset.data[group_by[0]]
          if column.dtype.name == "category":
              try:
                  indices = ((ind,) for ind in column.cat.categories)
              except NotImplementedError:
                  indices = (
                      (ind,) for ind in column.unique().compute()
                  )
          else:
              indices = ((ind,) for ind in column.unique().compute())
      else:
          group_tuples = dataset.data[group_by].itertuples()
          indices = util.unique_iterator(
              ind[1:] for ind in group_tuples
          )
      for coord in indices:
          if any(isinstance(c, float) and np.isnan(c) for c in coord):
              continue
          if len(coord) == 1:
              coord = coord[0]
          group = group_type(groupby.get_group(coord), **group_kwargs)
          data.append((coord, group))
      if issubclass(container_type, NdMapping):
          with item_check(False), sorted_context(False):
              return container_type(data, kdims=index_dims)
      else:
          return container_type(data)
  
imports: import sys
  import numpy
  import pandas
  from ..None import util
  from ..dimension import Dimension
  from ..element import Element
  from ..ndmapping import NdMapping, item_check, sorted_context
  from .interface import Interface
  from .pandas import PandasInterface
label_desc: Use image node_id 12 for calling the DaskInterface obj's underlying member method code with example usage: obj.groupby(cls, dataset, dimensions, container_type, group_type) and returns: container_type, container_type