docs: def where(self, cond, other=dtypes.NA, drop: bool = False):
          """Filter elements from this object according to a condition.
  
          This operation follows the normal broadcasting and alignment rules that
          xarray uses for binary arithmetic.
  
          Parameters
          ----------
          cond : DataArray or Dataset with boolean dtype
              Locations at which to preserve this object's values.
          other : scalar, DataArray or Dataset, optional
              Value to use for locations in this object where ``cond`` is False.
              By default, these locations filled with NA.
          drop : boolean, optional
              If True, coordinate labels that only correspond to False values of
              the condition are dropped from the result. Mutually exclusive with
              ``other``.
  
          Returns
          -------
          Same type as caller.
  
          Examples
          --------
  
          >>> import numpy as np
          >>> a = xr.DataArray(np.arange(25).reshape(5, 5), dims=('x', 'y'))
          >>> a.where(a.x + a.y < 4)
          <xarray.DataArray (x: 5, y: 5)>
          array([[  0.,   1.,   2.,   3.,  nan],
                 [  5.,   6.,   7.,  nan,  nan],
                 [ 10.,  11.,  nan,  nan,  nan],
                 [ 15.,  nan,  nan,  nan,  nan],
                 [ nan,  nan,  nan,  nan,  nan]])
          Dimensions without coordinates: x, y
          >>> a.where(a.x + a.y < 5, -1)
          <xarray.DataArray (x: 5, y: 5)>
          array([[ 0,  1,  2,  3,  4],
                 [ 5,  6,  7,  8, -1],
                 [10, 11, 12, -1, -1],
                 [15, 16, -1, -1, -1],
                 [20, -1, -1, -1, -1]])
          Dimensions without coordinates: x, y
          >>> a.where(a.x + a.y < 4, drop=True)
          <xarray.DataArray (x: 4, y: 4)>
          array([[  0.,   1.,   2.,   3.],
                 [  5.,   6.,   7.,  nan],
                 [ 10.,  11.,  nan,  nan],
                 [ 15.,  nan,  nan,  nan]])
          Dimensions without coordinates: x, y
  
          See also
          --------
          numpy.where : corresponding numpy function
          where : equivalent function
          """
          from .alignment import align
          from .dataarray import DataArray
          from .dataset import Dataset
  
          if drop:
              if other is not dtypes.NA:
                  raise ValueError('cannot set `other` if drop=True')
  
              if not isinstance(cond, (Dataset, DataArray)):
                  raise TypeError("cond argument is %r but must be a %r or %r" %
                                  (cond, Dataset, DataArray))
  
              # align so we can use integer indexing
              self, cond = align(self, cond)
  
              # get cond with the minimal size needed for the Dataset
              if isinstance(cond, Dataset):
                  clipcond = cond.to_array().any('variable')
              else:
                  clipcond = cond
  
              # clip the data corresponding to coordinate dims that are not used
              nonzeros = zip(clipcond.dims, np.nonzero(clipcond.values))
              indexers = {k: np.unique(v) for k, v in nonzeros}
  
              self = self.isel(**indexers)
              cond = cond.isel(**indexers)
  
          return ops.where_method(self, cond, other)