docs: def from_iris(cube):
      """ Convert a Iris cube into an DataArray
      """
      import iris.exceptions
      from xarray.core.pycompat import dask_array_type
  
      name = _name(cube)
      if name == 'unknown':
          name = None
      dims = []
      for i in range(cube.ndim):
          try:
              dim_coord = cube.coord(dim_coords=True, dimensions=(i,))
              dims.append(_name(dim_coord))
          except iris.exceptions.CoordinateNotFoundError:
              dims.append("dim_{}".format(i))
  
      if len(set(dims)) != len(dims):
          duplicates = [k for k, v in Counter(dims).items() if v > 1]
          raise ValueError('Duplicate coordinate name {}.'.format(duplicates))
  
      coords = OrderedDict()
  
      for coord in cube.coords():
          coord_attrs = _iris_obj_to_attrs(coord)
          coord_dims = [dims[i] for i in cube.coord_dims(coord)]
          if coord_dims:
              coords[_name(coord)] = (coord_dims, coord.points, coord_attrs)
          else:
              coords[_name(coord)] = ((), coord.points.item(), coord_attrs)
  
      array_attrs = _iris_obj_to_attrs(cube)
      cell_methods = _iris_cell_methods_to_str(cube.cell_methods)
      if cell_methods:
          array_attrs['cell_methods'] = cell_methods
  
      # Deal with iris 1.* and 2.*
      cube_data = cube.core_data() if hasattr(cube, 'core_data') else cube.data
  
      # Deal with dask and numpy masked arrays
      if isinstance(cube_data, dask_array_type):
          from dask.array import ma as dask_ma
          filled_data = dask_ma.filled(cube_data, get_fill_value(cube.dtype))
      elif isinstance(cube_data, np.ma.MaskedArray):
          filled_data = np.ma.filled(cube_data, get_fill_value(cube.dtype))
      else:
          filled_data = cube_data
  
      dataarray = DataArray(filled_data, coords=coords, name=name,
                            attrs=array_attrs, dims=dims)
      decoded_ds = decode_cf(dataarray._to_temp_dataset())
      return dataarray._from_temp_dataset(decoded_ds)