What happened?

When subsetting a DataArray along a dimension down to a single item, the other coordinate variables gain this scalar coordinate.

What did you expect to happen?

Coordinate variables should not have their coordinates changed.

Minimal Complete Verifiable Example

```Python import numpy as np import xarray as xr

lat = np.array([25, 35, 45]) lon = np.array([-105, -95, -85, -75]) time = np.array([0, 1])

data = np.arange(lat.size * lon.size * time.size) test_data = xr.DataArray(data.reshape((time.size, lat.size, lon.size)), coords=dict(lat=lat, lon=lon, time=time), dims=('time', 'lat', 'lon'))

print(test_data.lat.coords) # Only 'lat' print(test_data.isel(time=0).lat.coords) # Has both 'lat' and 'time' pritn(test_data.isel(time=[0, 1]).lat.coords) # Only 'lat' ```

MVCE confirmation

• [X] Minimal example — the example is as focused as reasonably possible to demonstrate the underlying issue in xarray.
• [X] Complete example — the example is self-contained, including all data and the text of any traceback.
• [X] Verifiable example — the example copy & pastes into an IPython prompt or Binder notebook, returning the result.
• [X] New issue — a search of GitHub Issues suggests this is not a duplicate.

Relevant log output

No response

Anything else we need to know?

This occurs with both the latest 2022.11.0 release and current main.

Environment

I ran into this issue with a netCDF file with the following time variable: ``` double time1(time1) ; time1:_FillValue = NaN ; time1:standard_name = "time" ; time1:long_name = "time" ; time1:udunits = "Hour since 2017-09-05T12:00:00Z" ; time1:units = "Hour since 2017-09-05T12:00:00+00:00" ; time1:calendar = "proleptic_gregorian" ;

time1 = 0, 3, 6, 9, 12, 15, 18, 21, 24 ; but we can reproduce the problem with something as simple as:python import numpy as np import xarray as xr

t = np.array(['2017-09-05T12:00:00.000000000', '2017-09-05T15:00:00.000000000'], dtype='datetime64[ns]') da = xr.DataArray(np.ones(t.shape), dims=('time',), coords=(t,))

da.loc[{'time':t[0]}] # Works on pandas 1.0.5 this produces:pytb

KeyError Traceback (most recent call last) <ipython-input-11-3e0afa0bd195> in <module> ----> 1 da.loc[{'time':t[0]}]

~/miniconda3/envs/py38/lib/python3.8/site-packages/xarray/core/dataarray.py in getitem(self, key) 196 labels = indexing.expanded_indexer(key, self.data_array.ndim) 197 key = dict(zip(self.data_array.dims, labels)) --> 198 return self.data_array.sel(**key) 199 200 def setitem(self, key, value) -> None:

~/miniconda3/envs/py38/lib/python3.8/site-packages/xarray/core/dataarray.py in sel(self, indexers, method, tolerance, drop, **indexers_kwargs) 1147 1148 """ -> 1149 ds = self._to_temp_dataset().sel( 1150 indexers=indexers, 1151 drop=drop,

~/miniconda3/envs/py38/lib/python3.8/site-packages/xarray/core/dataset.py in sel(self, indexers, method, tolerance, drop, **indexers_kwargs) 2099 """ 2100 indexers = either_dict_or_kwargs(indexers, indexers_kwargs, "sel") -> 2101 pos_indexers, new_indexes = remap_label_indexers( 2102 self, indexers=indexers, method=method, tolerance=tolerance 2103 )

~/miniconda3/envs/py38/lib/python3.8/site-packages/xarray/core/coordinates.py in remap_label_indexers(obj, indexers, method, tolerance, **indexers_kwargs) 394 } 395 --> 396 pos_indexers, new_indexes = indexing.remap_label_indexers( 397 obj, v_indexers, method=method, tolerance=tolerance 398 )

~/miniconda3/envs/py38/lib/python3.8/site-packages/xarray/core/indexing.py in remap_label_indexers(data_obj, indexers, method, tolerance) 268 coords_dtype = data_obj.coords[dim].dtype 269 label = maybe_cast_to_coords_dtype(label, coords_dtype) --> 270 idxr, new_idx = convert_label_indexer(index, label, dim, method, tolerance) 271 pos_indexers[dim] = idxr 272 if new_idx is not None:

~/miniconda3/envs/py38/lib/python3.8/site-packages/xarray/core/indexing.py in convert_label_indexer(index, label, index_name, method, tolerance) 187 indexer = index.get_loc(label.item()) 188 else: --> 189 indexer = index.get_loc( 190 label.item(), method=method, tolerance=tolerance 191 )

~/miniconda3/envs/py38/lib/python3.8/site-packages/pandas/core/indexes/datetimes.py in get_loc(self, key, method, tolerance) 620 else: 621 # unrecognized type --> 622 raise KeyError(key) 623 624 try:

KeyError: 1504612800000000000 ```

what's interesting is changing the units of datetime64 to [s] works: ```python import numpy as np import xarray as xr

t = np.array(['2017-09-05T12:00:00.000000000', '2017-09-05T15:00:00.000000000'], dtype='datetime64[s]') da = xr.DataArray(np.ones(t.shape), dims=('time',), coords=(t,)) da.loc[{'time':t[0]}] # Works ```

Environment: Python 3.8 from conda-forge on macOS 10.15.4

By default, xarray tries to decode times with pandas and falls back to cftime. This fixes the exception handler to fallback properly in the cases an unhandled abbreviated unit is passed in.

An additional item here would be to add support for msec, etc. to xarray's handling, but I wasn't sure the best way to handle that. I'm happy just if things properly fall back to cftime.

• [ ] Closes #xxxx
• [x] Tests added
• [x] Passes isort -rc . && black . && mypy . && flake8
• [x] Fully documented, including whats-new.rst for all changes and api.rst for new API

This matches pandas and makes it possible to pass a datetime dataarray to something expecting to be able to use strftime().

• [x] Closes #2090
• [x] Tests added (for all bug fixes or enhancements)
• [x] Tests passed (for all non-documentation changes)
• [x] Fully documented, including whats-new.rst for all changes and api.rst for new API

Universal wheels indicate that one wheel supports Python 2 and 3. This is no longer the case for xarray. This causes builds to generate files with names like xarray-0.13.0-py2.py3-none-any.whl, which can cause pip to incorrectly install the wheel on Python 2 when installing from a list of wheel files.

There's no easy way currently to control the conversion to string of time values/series. For this purpose, Panda's own .dt attribute has an implementation of strftime.

Is there interest in adding similar functionality to xarray?

Need '::' to introduce a code literal block. This was causing MetPy's doc build to warn (since we inherit AbstractDataStore).

The CF standard permits both values, and them to have different values, so we should not be treating this as an error--just mask out all of them.

• [x] Closes #1749 (remove if there is no corresponding issue, which should only be the case for minor changes)
• [x] Tests added (for all bug fixes or enhancements)
• [x] Tests passed (for all non-documentation changes)
• [x] Fully documented, including whats-new.rst for all changes and api.rst for new API (remove if this change should not be visible to users, e.g., if it is an internal clean-up, or if this is part of a larger project that will be documented later)

So this exception: ``` ValueError: Conflicting _FillValue and missing_value attrs on a variable 'MergedBaseReflectivityQC_altitude_above_msl': -999.0 vs. -99.0

Consider opening the offending dataset using decode_cf=False, correcting the attrs and decoding explicitly using xarray.decode_cf(). `` Why is having_FillValueandmissing_valuedifferent considered an error in decoding CF? It's perfectly CF-compliant, especially since_FillValueis a scalar (used by the netCDF library to initialize an array), andmissing_value` can be a vector (representing one or more undefined or invalid values).

This happens in this case because the source GRIB file has one value specified for "missing" (maps to missing_value) and another for "no coverage" (which has been mapped to _FillValue).

Is this a technical limitation? Or just something that needs an implementation?

Make the filename argument to NetCDF4DataStore polymorphic so that a Dataset can be passed in.

• [x] Closes #1459
• [x] Tests added / passed
• [x] Passes git diff upstream/master | flake8 --diff
• [x] Fully documented, including whats-new.rst for all changes and api.rst for new API

1459 discussed adding an alternate constructor (i.e. a class method) to NetCDF4DataStore to allow this, which would be my preferred approach rather than making a filename polymorphic (via isinstance). Unfortunately, alternate constructors only work by taking one set of parameters (or setting defaults) and then passing them to the original constructor. Given that, there's no way to make an alternate constructor without also making the original constructor somehow aware of this functionality--or breaking backwards-compatibility. I'm open to suggestions to the contrary.

It would be really handy to be able to initialize a xarray.Dataset instance from an already opened instance of netCDF4.Dataset. I have a lot of code where I'm already returning an opened netCDF4 file and this would streamline the process of hooking xarray into that.

It seems like the quick solution here would be to make NetCDF4DataStore accept a netCDF4.Dataset instance as filename, which would bypass the creation of a new instance. Thoughts?