class_docstr: Interface for simple dictionary-based dataset format using a
  compressed representation that uses the cartesian product between
  key dimensions. As with DictInterface, the dictionary keys correspond
  to the column (i.e. dimension) names and the values are NumPy arrays
  representing the values in that column.
  
  To use this compressed format, the key dimensions must be orthogonal
  to one another with each key dimension specifying an axis of the
  multidimensional space occupied by the value dimension data. For
  instance, given an temperature recordings sampled regularly across
  the earth surface, a list of N unique latitudes and M unique
  longitudes can specify the position of NxM temperature samples.
code: def select(cls, dataset, selection_mask=None, **selection):
      if selection_mask is not None:
          raise ValueError(
              f"Masked selections currently not supported for {cls.__name__}."
          )
  
      dimensions = dataset.kdims
      val_dims = [vdim for vdim in dataset.vdims if vdim in selection]
      if val_dims:
          raise IndexError(
              "Cannot slice value dimensions in compressed format, "
              "convert to expanded format before slicing."
          )
  
      indexed = cls.indexed(dataset, selection)
      full_selection = [
          (d, selection.get(d.name, selection.get(d.label)))
          for d in dimensions
      ]
      data = {}
      value_select = []
      for i, (dim, ind) in enumerate(full_selection):
          irregular = cls.irregular(dataset, dim)
          values = cls.coords(dataset, dim, irregular)
          mask = cls.key_select_mask(dataset, values, ind)
          if irregular:
              if np.isscalar(ind) or isinstance(ind, (set, list)):
                  raise IndexError(
                      "Indexing not supported for irregularly "
                      f"sampled data. {ind} value along {dim} dimension."
                      "must be a slice or 2D boolean mask."
                  )
              mask = mask.max(axis=i)
          elif dataset._binned:
              edges = cls.coords(dataset, dim, False, edges=True)
              inds = np.argwhere(mask)
              if np.isscalar(ind):
                  emin, emax = edges.min(), edges.max()
                  if ind < emin:
                      raise IndexError(
                          f"Index {ind} less than lower bound "
                          f"of {emin} for {dim} dimension."
                      )
                  elif ind >= emax:
                      raise IndexError(
                          f"Index {ind} more than or equal to upper bound "
                          f"of {emax} for {dim} dimension."
                      )
                  idx = max([np.digitize([ind], edges)[0] - 1, 0])
                  mask = np.zeros(len(values), dtype=np.bool_)
                  mask[idx] = True
                  values = edges[idx : idx + 2]
              elif len(inds):
                  values = edges[inds.min() : inds.max() + 2]
              else:
                  values = edges[0:0]
          else:
              values = values[mask]
          values, mask = np.asarray(values), np.asarray(mask)
          value_select.append(mask)
          data[dim.name] = (
              np.array([values]) if np.isscalar(values) else values
          )
  
      int_inds = [np.argwhere(v) for v in value_select][::-1]
      index = np.ix_(
          *[
              np.atleast_1d(np.squeeze(ind))
              if ind.ndim > 1
              else np.atleast_1d(ind)
              for ind in int_inds
          ]
      )
  
      for kdim in dataset.kdims:
          if cls.irregular(dataset, dim):
              da = dask_array_module()
              if da and isinstance(dataset.data[kdim.name], da.Array):
                  data[kdim.name] = dataset.data[kdim.name].vindex[
                      index
                  ]
              else:
                  data[kdim.name] = np.asarray(data[kdim.name])[index]
  
      for vdim in dataset.vdims:
          da = dask_array_module()
          if da and isinstance(dataset.data[vdim.name], da.Array):
              data[vdim.name] = dataset.data[vdim.name].vindex[index]
          else:
              data[vdim.name] = np.asarray(dataset.data[vdim.name])[
                  index
              ]
  
      if indexed:
          if len(dataset.vdims) == 1:
              da = dask_array_module()
              arr = np.squeeze(data[dataset.vdims[0].name])
              if da and isinstance(arr, da.Array):
                  arr = arr.compute()
              return arr if np.isscalar(arr) else arr[()]
          else:
              return np.array(
                  [np.squeeze(data[vd.name]) for vd in dataset.vdims]
              )
      return data
  
imports: from collections import defaultdict
  import numpy
  from ..None import util
  from ..dimension import dimension_name
  from ..element import Element
  from ..ndmapping import NdMapping, item_check, sorted_context
  from .dictionary import DictInterface
  from .interface import DataError, Interface
  from .util import dask_array_module, finite_range, get_array_types, is_dask
label_desc: Use image node_id 22 for calling the GridInterface obj's underlying member method code with example usage: obj.select(cls, dataset, selection_mask) and returns: data, unknown, np