.swap_dims() loses indexes of non-dimension variables

[Reshief]

What happened?

A rather obscure issue this time:

When trying to rename a few dimensions and variable names of an old dataset, the resulting xarray lost all attributes on other variables in the dataset.
More specifically, I could narrow it down to a very specific sequence of steps:

1. We need a dataset with a multi-index
2. We apply swap_dims() to an arbitrary dimension d that is not part of any multi-index
3. We rename a variable that is a member of a multi-index that does not have the dimension d neither on any of its levels nor on the overall index.
4. Levels within the same multi-index as the last renamed variable lose all of their .attrs.

As far as I could figure out, this does not happen if d is a dimension of any of the levels of the multi-index or the renamed variable has the dimension d.
If the dimension is not first swapped before the variable is renamed, the attributes are preserved.
If there is no multi-index, the issue does not seem to occur.
The attributes are lost upon the call to .rename but also on an equivalent call to .rename_vars.
The loss of attributes seems to only occur for the combination of: Multi-index, swap_dim of unrelated dimension, rename variable in multi-index.

What did you expect to happen?

I expect the attributes of the multi-index levels to persist through the renaming operations.
Specifically, I expect the attributes of variables that are not involved in the renaming operations to not be modified by the renaming since there is no naming conflict.

Minimal Complete Verifiable Example

# /// script
# requires-python = ">=3.11"
# dependencies = [
#   "xarray[complete]@git+https://github.com/pydata/xarray.git@main",
# ]
# ///
#
# This script automatically imports the development branch of xarray to check for issues.
# Please delete this header if you have _not_ tested this script with `uv run`!

import xarray as xr
xr.show_versions()
# your reproducer code ...

ds = xr.Dataset(coords={'time': ('midx_dim', [0.0], {'units': 'fs'}), 'trajid': ('midx_dim', [2], {'long_name': 'Trajectory ID'})})

ds = ds.set_xindex(["time", "trajid"])
print(f"{ds.time.attrs=}") # Output: ds.time.attrs={'units': 'fs'}
ds = ds.assign(hello=("nothing", [1,2,3],{"hi":3}))
print(f"{ds.time.attrs=}") # Output: ds.time.attrs={'units': 'fs'}
ds = ds.swap_dims(nothing='hello')
print(f"{ds.time.attrs=}") # Output: ds.time.attrs={'units': 'fs'}
ds = ds.rename(trajid="atrajectory")
print(f"{ds.time.attrs=}") # Output: ds.time.attrs={}

Steps to reproduce

See the minimum example above:
We create a dataset, build a multi-index, add another variable with unrelated dimension, swap that unrelated dimension, then rename a coordinate in the multi-index and suddenly the attributes of .time and .atrajectory are gone.
In the example I printed only the attributes of .time, but the issue also happens to .trajid/.atrajectory and in another case seems to have affected all levels of multi-indices within the dataset.

There never seemed to be an impact on non-coordinate variables.
Only coordinates were affected

MVCE confirmation

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

Relevant log output

Anything else we need to know?

To me this implies that it may be an issue of the treatment of multi-indexes either during swap_dim or during the renaming process.
I would assume that create_new_variables for the multi-index may be the culprit and may produce new variables without attributes if indexes have been left in an inconsistent state after swap_dim, but I am not sure.

Environment

Details

INSTALLED VERSIONS ------------------ commit: None python: 3.13.9 (tags/v3.13.9:8183fa5, Oct 14 2025, 14:09:13) [MSC v.1944 64 bit (AMD64)] python-bits: 64 OS: Windows OS-release: 11 machine: AMD64 processor: AMD64 Family 25 Model 117 Stepping 2, AuthenticAMD byteorder: little LC_ALL: None LANG: en_US.UTF-8 LOCALE: ('de_DE', 'cp1252') libhdf5: None libnetcdf: None

xarray: 2025.12.0
pandas: 3.0.0
numpy: 2.3.0
scipy: 1.15.3
netCDF4: None
pydap: None
h5netcdf: None
h5py: None
zarr: None
cftime: None
nc_time_axis: None
iris: None
bottleneck: None
dask: None
distributed: None
matplotlib: 3.10.3
cartopy: None
seaborn: None
numbagg: None
fsspec: None
cupy: None
pint: None
sparse: None
flox: None
numpy_groupies: None
setuptools: None
pip: 25.2
conda: None
pytest: None
mypy: None
IPython: None
sphinx: None

[welcome]

Thanks for opening your first issue here at xarray! Be sure to follow the issue template!
If you have an idea for a solution, we would really welcome a Pull Request with proposed changes.
See the Contributing Guide for more.
It may take us a while to respond here, but we really value your contribution. Contributors like you help make xarray better.
Thank you!

[Reshief]

After some digging, I think I narrowed it down to where it happens. Not sure, why it needs the swap_dims first, but this is how it happens:

In Dataset._rename_indexes(), the value of name_dict is {'trajid': 'atrajectory'}, but coord_names={'midx_dim':...} therefore, new_coord_names=['midx_dim'] and therefore, only the variable for midx_dim is passed to PandasMultiIndex.create_variables().
The latter function, however tries to read the variable attributes for all index variables from the passed variables parameter, which only contains the midx_dim variable.

It cannot find a variable for time or trajid and therefore creates a new IndexVariable, which has the correct data, but it loses its attrs and encoding, because those are set to {}.
However, then, the return value of create_variables() contains the keys for time and trajid and those lead to the original variables in the dataset being overwritten.

I see two options for solving the issue:

1. Pass all variables that were present on the old dataset to Index.create_variables() so the attrs and encoding lookup can find the metadata. create_variables should only read those anyway, I assume.
2. Make the function create_variables do a more complex lookup to find previously existing variables that are not in coord_names for the respective index.
   2.1: Maybe the coord_names in ds._rename_indexes should have all levels of the multi-index? Then the question would be whether all levels of the multi-index should be in the coord_names result and why they are no longer in there after the prior call to swap_dims()

[Reshief]

After some more investigation, it seems to me, that the issue is in ds.swap_dims().

In the example, when we start going into swap_dims(), we have the following indexes:

self._indexes={'midx_dim': PandasIndex(MultiIndex([(0.0, 2)],
           name='midx_dim')), 'time': PandasIndex(MultiIndex([(0.0, 2)],
           name='midx_dim')), 'trajid': PandasIndex(MultiIndex([(0.0, 2)],
           name='midx_dim'))}

When we leave swap_dims(), the variables are correctly reassigned, the coordinates are set to

coord_names={'midx_dim', 'trajid', 'time'}

but the indexes are updated to

indexes={'midx_dim': PandasIndex(MultiIndex([(0.0, 2)],
           name='midx_dim'))}

Why do we lose theindexes?

Looking at the code in .swap_dims(), indexes are only copied, if they are associated with a dimension:

        variables: dict[Hashable, Variable] = {}
        indexes: dict[Hashable, Index] = {}
        for current_name, current_variable in self.variables.items():
            dims = tuple(dims_dict.get(dim, dim) for dim in current_variable.dims)
            var: Variable
            # We only go in here, if our current variable is a resulting dimension
            if current_name in result_dims:
                var = current_variable.to_index_variable()
                var.dims = dims
                if current_name in self._indexes:
                    # Index copied if the current dimension had an index
                    indexes[current_name] = self._indexes[current_name] 
                    variables[current_name] = var 
                else:
                    # New index created if we promote a variable to a coordinate
                    index, index_vars = create_default_index_implicit(var)
                    indexes.update(dict.fromkeys(index_vars, index))
                    variables.update(index_vars)
                    coord_names.update(index_vars)
            else:
                # if the variable is not the name of a dimension, we do not copy its index
                # e.g. time and trajid don't get their indexes copied.
                var = current_variable.to_base_variable()
                var.dims = dims

For non-dimension coordinates, their indexes do not get copied.
This leads to the _rename_indexes() call in rename_vars to not pass them to create_vars and therefore they are replaced with replacement variables with no metadata.

Solution

I see multiple ways to go about it.

Alternative 1:

The simplest solution I have found is adding code to copy indexes of non-dimensions to the result.
This would e.g. result in

            else:
                # if the variable is not the name of a dimension, we do not copy its index
                # e.g. time and trajid don't get their indexes copied.
                var = current_variable.to_base_variable()
                var.dims = dims
                if current_name in self._indexes:
                    indexes[current_name] = self._indexes[current_name]

This would effectively mean that we keep all indexes on the dataset and only create a new index for coordinates/variables that are promoted to dimension-coordinates by the swap.

For me, this would fit with how the new coord_names are computed: Copy over all old coordinates and add variables whose names coincide with the names of renamed dimensions.
The dataset does not demote coordinates only if their dimension is renamed.
Consequently, we could keep all indexes and only add new indexes for promoted variables.

Alternative 2:

We can copy over all indexes, create new indexes for promoted variables and remove indexes for demoted coordinates.

If we want to remove indexes of coordinates that are no longer dimension-coordinates after the rename, the logic may get more complicated.
I am a bit unsure about this from the documentation, whether one should expect the index of coordinate x to vanish, if we rename x to z.
In my mind, I would not expect the index to disappear if x is still a coordinate after the rename.
I honestly would rather expect that the coordinate of the same name would also be renamed.
If .swap_dims() is explicitly meant to not rename any coordinates, I would still advocate for the index of an existing coordinate to be kept across the swap of the dimension name.
The documentation only says swap_dims returns a container with swapped dimensions. It does not specify that the old coordinate would lose its index.

Nevertheless, I would suggest that Alternative 1 is probably the easiest way to go about it?
I will send a pull request for option 1. If you would like the semantics of the swap_dims() function to be different, please let me know.

EDIT: After checking the tests, I came to the conclusion, that alternative 1 is too simple and would break some prior behavior. I have implemented a version of Alternative 2 and opened a corresponding pull request

[Reshief]

The minimum viable example would boil down to something like this now:

ds = xr.Dataset(
    data_vars={"var1": ("dim1", [1, 3])},
    coords={
        "coord1": ("midx_dim", [0.0]),
        "coord2": ("midx_dim", [2]),
    },
)
ds = ds.set_xindex(["coord1", "coord2"])
assert "coord1" in ds.indexes and "coord2" in ds.indexes and "midx_dim" in ds.indexes
ds_swapped = ds.swap_dims(dim1="dim1_")
ds_renamed = ds.rename(dim1="dim1_")
print(ds_swapped.indexes)
# Indexes:
#       midx_dim  MultiIndex([(0.0, 2)],
#            name='midx_dim')
print(ds_renamed.indexes)
# Indexes:
#         ┌ midx_dim  MultiIndex([(0.0, 2)],
#                 name='midx_dim')
#         │ coord1
#         └ coord2
# This fails
assert (
    "coord1" in ds_swapped.indexes
    and "coord2" in ds_swapped.indexes
    and "midx_dim" in ds_swapped.indexes
) 

I.e. rename() preserves all indexes, but swap_dims() does not.