losing shallowness of ds.copy() on ds from xr.open_dataset

MCVE Code Sample

import numpy as np
import xarray as xr

xlen = 4
x = xr.DataArray(np.linspace(0.0, 1.0, xlen), dims=('x'))

varname = 'foo'
xr.Dataset({varname: xr.DataArray(np.arange(xlen, dtype='float64'), dims=('x'), coords={'x': x})}).to_netcdf('ds.nc')
    
with xr.open_dataset('ds.nc') as ds:
    ds2 = ds.copy()
    ds2[varname][0] = 11.0
    print(f'ds.equals = {ds.equals(ds2)}')

with xr.open_dataset('ds.nc') as ds:
    ds2 = ds.copy()
    print(f'ds.equals = {ds.equals(ds2)}')
    ds2[varname][0] = 11.0
    print(f'ds.equals = {ds.equals(ds2)}')

Expected Output

I expect the code to write out

ds.equals = True
ds.equals = True
ds.equals = True

However, when I run it, the last line is

ds.equals = False

Problem Description

The code above writes a small xr.Dataset to a netCDF file.
There are 2 context managers opening the netCDF file as ds.
Both context manager blocks start by setting ds2 to a shallow copy of ds.

In the first context manager block, a value in ds2 is modified, and ds2 is compared to ds. The Datasets are still equal, confirming that the copy is shallow.

The second context manager block is the same as the first, except that ds2 is compared to ds prior changing the value the value in ds2. When this is done, the Datasets are no longer equal, indicating that ds2 is no longer a shallow copy of ds.

I don't understand how evaluating ds.equals(ds2), prior to changing a value in ds2, could decouple ds2 from ds.

I only observe this behavior when ds is set via xr.open_dataset. I don't see it when I create ds directly using xr.Dataset.

I'm rather perplexed by this.

Output of xr.show_versions()

Start by running the MCVE with xr.open_dataset, Dataset.copy(), and Dataset.equals() to reproduce the difference between the two context-manager blocks. Trace the copy and equality behavior around the opened netCDF dataset; done means the expected equality output remains true after the comparison and subsequent modification.