docs: def open_dataarray(filename_or_obj, group=None, decode_cf=True,
                     mask_and_scale=None, decode_times=True, autoclose=None,
                     concat_characters=True, decode_coords=True, engine=None,
                     chunks=None, lock=None, cache=None, drop_variables=None,
                     backend_kwargs=None, use_cftime=None):
      """Open an DataArray from a netCDF file containing a single data variable.
  
      This is designed to read netCDF files with only one data variable. If
      multiple variables are present then a ValueError is raised.
  
      Parameters
      ----------
      filename_or_obj : str, Path, file or xarray.backends.*DataStore
          Strings and Paths are interpreted as a path to a netCDF file or an
          OpenDAP URL and opened with python-netCDF4, unless the filename ends
          with .gz, in which case the file is gunzipped and opened with
          scipy.io.netcdf (only netCDF3 supported). Byte-strings or file-like
          objects are opened by scipy.io.netcdf (netCDF3) or h5py (netCDF4/HDF).
      group : str, optional
          Path to the netCDF4 group in the given file to open (only works for
          netCDF4 files).
      decode_cf : bool, optional
          Whether to decode these variables, assuming they were saved according
          to CF conventions.
      mask_and_scale : bool, optional
          If True, replace array values equal to `_FillValue` with NA and scale
          values according to the formula `original_values * scale_factor +
          add_offset`, where `_FillValue`, `scale_factor` and `add_offset` are
          taken from variable attributes (if they exist).  If the `_FillValue` or
          `missing_value` attribute contains multiple values a warning will be
          issued and all array values matching one of the multiple values will
          be replaced by NA. mask_and_scale defaults to True except for the
          pseudonetcdf backend.
      decode_times : bool, optional
          If True, decode times encoded in the standard NetCDF datetime format
          into datetime objects. Otherwise, leave them encoded as numbers.
      concat_characters : bool, optional
          If True, concatenate along the last dimension of character arrays to
          form string arrays. Dimensions will only be concatenated over (and
          removed) if they have no corresponding variable and if they are only
          used as the last dimension of character arrays.
      decode_coords : bool, optional
          If True, decode the 'coordinates' attribute to identify coordinates in
          the resulting dataset.
      engine : {'netcdf4', 'scipy', 'pydap', 'h5netcdf', 'pynio', 'cfgrib'}, \
          optional
          Engine to use when reading files. If not provided, the default engine
          is chosen based on available dependencies, with a preference for
          'netcdf4'.
      chunks : int or dict, optional
          If chunks is provided, it used to load the new dataset into dask
          arrays.
      lock : False or duck threading.Lock, optional
          Resource lock to use when reading data from disk. Only relevant when
          using dask or another form of parallelism. By default, appropriate
          locks are chosen to safely read and write files with the currently
          active dask scheduler.
      cache : bool, optional
          If True, cache data loaded from the underlying datastore in memory as
          NumPy arrays when accessed to avoid reading from the underlying data-
          store multiple times. Defaults to True unless you specify the `chunks`
          argument to use dask, in which case it defaults to False. Does not
          change the behavior of coordinates corresponding to dimensions, which
          always load their data from disk into a ``pandas.Index``.
      drop_variables: string or iterable, optional
          A variable or list of variables to exclude from being parsed from the
          dataset. This may be useful to drop variables with problems or
          inconsistent values.
      backend_kwargs: dictionary, optional
          A dictionary of keyword arguments to pass on to the backend. This
          may be useful when backend options would improve performance or
          allow user control of dataset processing.
      use_cftime: bool, optional
          Only relevant if encoded dates come from a standard calendar
          (e.g. 'gregorian', 'proleptic_gregorian', 'standard', or not
          specified).  If None (default), attempt to decode times to
          ``np.datetime64[ns]`` objects; if this is not possible, decode times to
          ``cftime.datetime`` objects. If True, always decode times to
          ``cftime.datetime`` objects, regardless of whether or not they can be
          represented using ``np.datetime64[ns]`` objects.  If False, always
          decode times to ``np.datetime64[ns]`` objects; if this is not possible
          raise an error.
  
      Notes
      -----
      This is designed to be fully compatible with `DataArray.to_netcdf`. Saving
      using `DataArray.to_netcdf` and then loading with this function will
      produce an identical result.
  
      All parameters are passed directly to `xarray.open_dataset`. See that
      documentation for further details.
  
      See also
      --------
      open_dataset
      """
  
      dataset = open_dataset(filename_or_obj, group=group, decode_cf=decode_cf,
                             mask_and_scale=mask_and_scale,
                             decode_times=decode_times, autoclose=autoclose,
                             concat_characters=concat_characters,
                             decode_coords=decode_coords, engine=engine,
                             chunks=chunks, lock=lock, cache=cache,
                             drop_variables=drop_variables,
                             backend_kwargs=backend_kwargs,
                             use_cftime=use_cftime)
  
      if len(dataset.data_vars) != 1:
          raise ValueError('Given file dataset contains more than one data '
                           'variable. Please read with xarray.open_dataset and '
                           'then select the variable you want.')
      else:
          data_array, = dataset.data_vars.values()
  
      data_array._file_obj = dataset._file_obj
  
      # Reset names if they were changed during saving
      # to ensure that we can 'roundtrip' perfectly
      if DATAARRAY_NAME in dataset.attrs:
          data_array.name = dataset.attrs[DATAARRAY_NAME]
          del dataset.attrs[DATAARRAY_NAME]
  
      if data_array.name == DATAARRAY_VARIABLE:
          data_array.name = None
  
      return data_array