Jun 6, 2025 · Jun 6, 2025 · Jun 13, 2025 · Jun 14, 2025 · Jun 14, 2025
diff --git a/xarray/backends/api.py b/xarray/backends/api.py
    MutableMapping,
    Sequence,
 )
 from dataclasses import asdict, fields
 from functools import partial
 from io import BytesIO
 from numbers import Number
 from xarray.backends.common import (
    AbstractDataStore,
    ArrayWriter,
    BackendOptions,
    CoderOptions,
    XarrayBackendOptions,
    _find_absolute_paths,
    _normalize_path,
    _reset_dataclass_to_false,
    return tree


 from dataclasses import asdict, fields

 Buffer = Union[bytes, bytearray, memoryview]


 from xarray.backends.common import BackendOptions, CoderOptions, XarrayBackendOptions

 # @dataclass(frozen=True)
 # class XarrayBackendOptions:
 #     chunks: Optional[T_Chunks] = None

    backend = plugins.get_backend(engine)

    print("XX0:", backend)
    print("XX1:", type(backend))
    print("XX2:", type(backend.coder_opts))
    print("XX3:", coder_opts)
    print("XX4:", backend.coder_opts)
    print("XX4-0:", kwargs)

    # initialize CoderOptions with decoders of not given
    # initialize CoderOptions with decoders if not given
    # Deprecation Fallback
    if coder_opts is False:  # or decode_cf is False:
    if coder_opts is False:
        coder_opts = _reset_dataclass_to_false(backend.coder_opts)
    elif coder_opts is True:
        coder_opts = backend.coder_opts
    elif coder_opts is None:
        print("XX4-1:", decode_cf)
        field_names = {f.name for f in fields(backend.coder_class)}
        decoders = _resolve_decoders_kwargs(
            decode_cf,
            decode_coords=decode_coords,
        )
        decoders["drop_variables"] = drop_variables
        print("XX4-2:", decoders)
        coder_opts = backend.coder_class(**decoders)

    print("XX5:", coder_opts)

    if backend_opts is None:
        backend_opts = XarrayBackendOptions(
            chunks=chunks,
            overwrite_encoded_chunks=kwargs.pop("overwrite_encoded_chunks", None),
        )

    print("XX6:", backend_opts)
    # Check if store_opts have been ovrridden in the subclass
    # That indicates new-style behaviour
    # We can keep backwards compatibility
    print("XX70:", kwargs)
    # Check if store_opts have been overridden in the subclass.
    # That indicates new-style behaviour.
    # We can keep backwards compatibility.
    _store_opts = backend.store_opts
    print("XX70a:", type(_store_opts))
    if type(_store_opts) is BackendOptions:
        coder_kwargs = asdict(coder_opts)
        print("XX7a:", kwargs)
        backend_ds = backend.open_dataset(
            filename_or_obj,
            **coder_kwargs,
            open_kwargs = {k: v for k, v in kwargs.items() if k in field_names}
            open_opts = backend.open_class(**open_kwargs)
        if store_opts is None:
            # check foropen kwargs and createopen_opts
            # check forstore kwargs and createstore_opts
            field_names = {f.name for f in fields(backend.store_class)}
            store_kwargs = {k: v for k, v in kwargs.items() if k in field_names}
            store_opts = backend.store_class(**store_kwargs)
        print("XX7b:", open_opts)
        print("XX7c:", store_opts)
        backend_ds = backend.open_dataset(
            filename_or_obj,
            coder_opts=coder_opts,
    kwargs["format"] = format
    kwargs["group"] = group

    # fill open_opts according backend
    kwargs_names = list(kwargs)
    field_names = {f.name for f in fields(backend.open_class)}
    open_kwargs = {k: kwargs.pop(k) for k in kwargs_names if k in field_names}
    open_opts = backend.open_class(**open_kwargs)

    # fill store_opts according backend
    field_names = {f.name for f in fields(backend.store_class)}
    store_kwargs = {k: kwargs.pop(k) for k in kwargs_names if k in field_names}
    store_opts = backend.store_class(**store_kwargs)

    # open_opts = mplex=autocomplex) if open_opts is None else open_opts
    # store_opts = backend.store_class(group=group, autoclose=autoclose) if store_opts is None else store_opts
    print("TN0:", open_opts)
    print("TN1:", store_opts)
    print("TN2:", mode)
    print("TN3:", kwargs)
    store = store_open(
        target, mode=mode, open_opts=open_opts, store_opts=store_opts, **kwargs
    )
diff --git a/xarray/backends/common.py b/xarray/backends/common.py
 import time
 import traceback
 from collections.abc import Hashable, Iterable, Mapping, Sequence
 from dataclasses import dataclass, fields, replace
 from glob import glob
 from typing import (
    TYPE_CHECKING,
 import numpy as np
 import pandas as pd

 from xarray.backends.locks import SerializableLock
 from xarray.coding import strings, variables
 from xarray.coding.times import CFDatetimeCoder, CFTimedeltaCoder
 from xarray.coding.variables import SerializationWarning
 NONE_VAR_NAME = "__values__"

 T = TypeVar("T")
 Buffer = Union[bytes, bytearray, memoryview]


 @overload
        return variables, attributes


 from dataclasses import dataclass, fields, replace

 Buffer = Union[bytes, bytearray, memoryview]


 def _reset_dataclass_to_false(instance):
    field_names = [f.name for f in fields(instance)]
    false_values = dict.fromkeys(field_names, False)
    pass


 from xarray.backends.locks import SerializableLock


 @dataclass(frozen=True)
 class StoreWriteOptions:
    group: Optional[str] = None

 @dataclass(frozen=True)
 class CoderOptions:
    # maybe add these two to disentangle masking from scaling?
    # mask: Optional[bool] = None
    # scale: Optional[bool] = None
    mask_and_scale: Optional[bool | Mapping[str, bool]] = None
diff --git a/xarray/backends/h5netcdf_.py b/xarray/backends/h5netcdf_.py
 import io
 import os
 from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any, Union
 from dataclasses import asdict, dataclass
 from typing import TYPE_CHECKING, Any, Optional, Union

 import numpy as np

 from xarray.backends.common import (
    BACKEND_ENTRYPOINTS,
    BackendEntrypoint,
    BackendOptions,
    WritableCFDataStore,
    _normalize_path,
    _open_remote_file,
    datatree_from_dict_with_io_cleanup,
    find_root_and_group,
 )
 from xarray.backends.file_manager import CachingFileManager, DummyFileManager
 from xarray.backends.locks import HDF5_LOCK, combine_locks, ensure_lock, get_write_lock
 from xarray.backends.locks import (
    HDF5_LOCK,
    SerializableLock,
    combine_locks,
    ensure_lock,
    get_write_lock,
 )
 from xarray.backends.netCDF4_ import (
    BaseNetCDF4Array,
    _build_and_get_enum,
    _get_datatype,
    _nc4_require_group,
 )
 from xarray.backends.netCDF4_ import NetCDF4CoderOptions as H5netcdfCoderOptions
 from xarray.backends.store import StoreBackendEntrypoint
 from xarray.core import indexing
 from xarray.core.utils import (
        cls,
        filename,
        mode="r",
        # format=None,
        # group=None,
        # lock=None,
        # autoclose=False,
        # invalid_netcdf=None,
        # phony_dims=None,
        # decode_vlen_strings=True,
        # driver=None,
        # driver_kwds=None,
        # storage_options: dict[str, Any] | None = None,
        open_opts=None,
        store_opts=None,
        **kwargs,
            raise ValueError("invalid format for h5netcdf backend")

        kwargs.update(open_kwargs)
        # kwargs.update(kwargs.pop("driver_kwds", None))
        #
        #     = {
        #     "invalid_netcdf": invalid_netcdf,
        #     "decode_vlen_strings": decode_vlen_strings,
        #     "driver": driver,
        # }
        driver_kwds = kwargs.pop("driver_kwds", None)
        if driver_kwds is not None:
            kwargs.update(driver_kwds)
        # check why this is needed in some cases, should not be in kwargs any more
        kwargs.pop("group", None)
        print("XX0:", kwargs)

        # if phony_dims is not None:
        #    kwargs["phony_dims"] = phony_dims
        lock = store_kwargs.get("lock", None)
        if lock is None:
            if mode == "r":
                lock = HDF5_LOCK
            else:
                lock = combine_locks([HDF5_LOCK, get_write_lock(filename)])
            store_kwargs["lock"] = lock
        print("XX1:", store_kwargs)
        manager = CachingFileManager(h5netcdf.File, filename, mode=mode, kwargs=kwargs)
        return cls(manager, mode=mode, **store_kwargs)

    )


 from dataclasses import asdict, dataclass
 from typing import Optional

 from xarray.backends.locks import SerializableLock

 Buffer = Union[bytes, bytearray, memoryview]
 from xarray.backends.common import BackendOptions
 from xarray.backends.netCDF4_ import NetCDF4CoderOptions as H5netcdfCoderOptions


 @dataclass(frozen=True)
 class H5netcdfStoreOptions(BackendOptions):
    group: Optional[str] = None
        filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore,
        *,
        mode="r",
        # mask_and_scale=True,
        # decode_times=True,
        # concat_characters=True,
        # decode_coords=True,
        # drop_variables: str | Iterable[str] | None = None,
        # use_cftime=None,
        # decode_timedelta=None,
        # format=None,
        # group=None,
        # lock=None,
        # invalid_netcdf=None,
        # phony_dims=None,
        # decode_vlen_strings=True,
        # driver=None,
        # driver_kwds=None,
        # storage_options: dict[str, Any] | None = None,
        coder_opts: H5netcdfCoderOptions = None,
        open_opts: H5netcdfOpenOptions = None,
        store_opts: H5netcdfStoreOptions = None,
        open_opts = open_opts if open_opts is not None else self.open_opts
        store_opts = store_opts if store_opts is not None else self.store_opts

        # Keep this message for some versions
        # remove and set phony_dims="access" above
        # emit_phony_dims_warning, phony_dims = _check_phony_dims(phony_dims)

        filename_or_obj = _normalize_path(filename_or_obj)
        store = H5NetCDFStore.open(
            filename_or_obj,
            mode=mode,
            open_opts=open_opts,
            store_opts=store_opts,
            # format=format,
            # group=group,
            # lock=lock,
            # invalid_netcdf=invalid_netcdf,
            # phony_dims=phony_dims,
            # decode_vlen_strings=decode_vlen_strings,
            # driver=driver,
            # driver_kwds=driver_kwds,
            # storage_options=storage_options,
            **kwargs,
        )

            coder_opts=coder_opts,
        )

        # only warn if phony_dims exist in file
        # remove together with the above check
        # after some versions
        # if store.ds._root._phony_dim_count > 0 and emit_phony_dims_warning:
        #    _emit_phony_dims_warning()

        return ds

    # def to_netcdf(
    #         self,
    #         filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore,
    #         *,
    #         coder_opts: H5netcdfCoderOptions = None,
    #         open_opts: H5netcdfOpenOptions = None,
    #         store_opts: H5netcdfStoreOptions = None,
    #         **kwargs,
    #         ):
    #

    def open_datatree(
        self,
        filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore,
Original file line number	Diff line number	Diff line change
Expand Up		@@ -9,6 +9,7 @@
		MutableMapping,
		Sequence,
		)
		from dataclasses import asdict, fields
		from functools import partial
		from io import BytesIO
		from numbers import Number
Expand All		@@ -29,6 +30,9 @@
		from xarray.backends.common import (
		AbstractDataStore,
		ArrayWriter,
		BackendOptions,
		CoderOptions,
		XarrayBackendOptions,
		_find_absolute_paths,
		_normalize_path,
		_reset_dataclass_to_false,
Expand DownExpand Up		@@ -475,13 +479,6 @@ def _datatree_from_backend_datatree(
		return tree


		from dataclasses import asdict, fields

		Buffer = Union[bytes, bytearray, memoryview]


		from xarray.backends.common import BackendOptions, CoderOptions, XarrayBackendOptions

		# @dataclass(frozen=True)
		# class XarrayBackendOptions:
		# chunks: Optional[T_Chunks] = None
Expand DownExpand Up		@@ -692,21 +689,13 @@ def open_dataset(

		backend = plugins.get_backend(engine)

		print("XX0:", backend)
		print("XX1:", type(backend))
		print("XX2:", type(backend.coder_opts))
		print("XX3:", coder_opts)
		print("XX4:", backend.coder_opts)
		print("XX4-0:", kwargs)

		# initialize CoderOptions with decoders of not given
		# initialize CoderOptions with decoders if not given
		# Deprecation Fallback
		if coder_opts is False: # or decode_cf is False:
		if coder_opts is False:
		coder_opts = _reset_dataclass_to_false(backend.coder_opts)
		elif coder_opts is True:
		coder_opts = backend.coder_opts
		elif coder_opts is None:
		print("XX4-1:", decode_cf)
		field_names = {f.name for f in fields(backend.coder_class)}
		decoders = _resolve_decoders_kwargs(
		decode_cf,
Expand All		@@ -719,11 +708,8 @@ def open_dataset(
		decode_coords=decode_coords,
		)
		decoders["drop_variables"] = drop_variables
		print("XX4-2:", decoders)
		coder_opts = backend.coder_class(**decoders)

		print("XX5:", coder_opts)

		if backend_opts is None:
		backend_opts = XarrayBackendOptions(
		chunks=chunks,
Expand All		@@ -734,16 +720,12 @@ def open_dataset(
		overwrite_encoded_chunks=kwargs.pop("overwrite_encoded_chunks", None),
		)

		print("XX6:", backend_opts)
		# Check if store_opts have been ovrridden in the subclass
		# That indicates new-style behaviour
		# We can keep backwards compatibility
		print("XX70:", kwargs)
		# Check if store_opts have been overridden in the subclass.
		# That indicates new-style behaviour.
		# We can keep backwards compatibility.
		_store_opts = backend.store_opts
		print("XX70a:", type(_store_opts))
		if type(_store_opts) is BackendOptions:
		coder_kwargs = asdict(coder_opts)
		print("XX7a:", kwargs)
		backend_ds = backend.open_dataset(
		filename_or_obj,
		**coder_kwargs,
Expand All		@@ -756,12 +738,10 @@ def open_dataset(
		open_kwargs = {k: v for k, v in kwargs.items() if k in field_names}
		open_opts = backend.open_class(**open_kwargs)
		if store_opts is None:
		# check foropen kwargs and createopen_opts
		# check forstore kwargs and createstore_opts
		field_names = {f.name for f in fields(backend.store_class)}
		store_kwargs = {k: v for k, v in kwargs.items() if k in field_names}
		store_opts = backend.store_class(**store_kwargs)
		print("XX7b:", open_opts)
		print("XX7c:", store_opts)
		backend_ds = backend.open_dataset(
		filename_or_obj,
		coder_opts=coder_opts,
Expand DownExpand Up		@@ -1988,21 +1968,17 @@ def to_netcdf(
		kwargs["format"] = format
		kwargs["group"] = group

		# fill open_opts according backend
		kwargs_names = list(kwargs)
		field_names = {f.name for f in fields(backend.open_class)}
		open_kwargs = {k: kwargs.pop(k) for k in kwargs_names if k in field_names}
		open_opts = backend.open_class(**open_kwargs)

		# fill store_opts according backend
		field_names = {f.name for f in fields(backend.store_class)}
		store_kwargs = {k: kwargs.pop(k) for k in kwargs_names if k in field_names}
		store_opts = backend.store_class(**store_kwargs)

		# open_opts = mplex=autocomplex) if open_opts is None else open_opts
		# store_opts = backend.store_class(group=group, autoclose=autoclose) if store_opts is None else store_opts
		print("TN0:", open_opts)
		print("TN1:", store_opts)
		print("TN2:", mode)
		print("TN3:", kwargs)
		store = store_open(
		target, mode=mode, open_opts=open_opts, store_opts=store_opts, **kwargs
		)
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -5,6 +5,7 @@
		import time
		import traceback
		from collections.abc import Hashable, Iterable, Mapping, Sequence
		from dataclasses import dataclass, fields, replace
		from glob import glob
		from typing import (
		TYPE_CHECKING,
Expand All		@@ -20,6 +21,7 @@
		import numpy as np
		import pandas as pd

		from xarray.backends.locks import SerializableLock
		from xarray.coding import strings, variables
		from xarray.coding.times import CFDatetimeCoder, CFTimedeltaCoder
		from xarray.coding.variables import SerializationWarning
Expand DownExpand Up		@@ -51,6 +53,7 @@
		NONE_VAR_NAME = "__values__"

		T = TypeVar("T")
		Buffer = Union[bytes, bytearray, memoryview]


		@overload
Expand DownExpand Up		@@ -656,11 +659,6 @@ def encode(self, variables, attributes):
		return variables, attributes


		from dataclasses import dataclass, fields, replace

		Buffer = Union[bytes, bytearray, memoryview]


		def _reset_dataclass_to_false(instance):
		field_names = [f.name for f in fields(instance)]
		false_values = dict.fromkeys(field_names, False)
Expand All		@@ -672,9 +670,6 @@ class BackendOptions:
		pass


		from xarray.backends.locks import SerializableLock


		@dataclass(frozen=True)
		class StoreWriteOptions:
		group: Optional[str] = None
Expand All		@@ -700,6 +695,7 @@ class XarrayBackendOptions:

		@dataclass(frozen=True)
		class CoderOptions:
		# maybe add these two to disentangle masking from scaling?
		# mask: Optional[bool] = None
		# scale: Optional[bool] = None
		mask_and_scale: Optional[bool \| Mapping[str, bool]] = None
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,21 +4,29 @@
		import io
		import os
		from collections.abc import Iterable
		from typing import TYPE_CHECKING, Any, Union
		from dataclasses import asdict, dataclass
		from typing import TYPE_CHECKING, Any, Optional, Union

		import numpy as np

		from xarray.backends.common import (
		BACKEND_ENTRYPOINTS,
		BackendEntrypoint,
		BackendOptions,
		WritableCFDataStore,
		_normalize_path,
		_open_remote_file,
		datatree_from_dict_with_io_cleanup,
		find_root_and_group,
		)
		from xarray.backends.file_manager import CachingFileManager, DummyFileManager
		from xarray.backends.locks import HDF5_LOCK, combine_locks, ensure_lock, get_write_lock
		from xarray.backends.locks import (
		HDF5_LOCK,
		SerializableLock,
		combine_locks,
		ensure_lock,
		get_write_lock,
		)
		from xarray.backends.netCDF4_ import (
		BaseNetCDF4Array,
		_build_and_get_enum,
Expand All		@@ -28,6 +36,7 @@
		_get_datatype,
		_nc4_require_group,
		)
		from xarray.backends.netCDF4_ import NetCDF4CoderOptions as H5netcdfCoderOptions
		from xarray.backends.store import StoreBackendEntrypoint
		from xarray.core import indexing
		from xarray.core.utils import (
Expand DownExpand Up		@@ -139,16 +148,6 @@ def open(
		cls,
		filename,
		mode="r",
		# format=None,
		# group=None,
		# lock=None,
		# autoclose=False,
		# invalid_netcdf=None,
		# phony_dims=None,
		# decode_vlen_strings=True,
		# driver=None,
		# driver_kwds=None,
		# storage_options: dict[str, Any] \| None = None,
		open_opts=None,
		store_opts=None,
		**kwargs,
Expand DownExpand Up		@@ -182,29 +181,19 @@ def open(
		raise ValueError("invalid format for h5netcdf backend")

		kwargs.update(open_kwargs)
		# kwargs.update(kwargs.pop("driver_kwds", None))
		#
		# = {
		# "invalid_netcdf": invalid_netcdf,
		# "decode_vlen_strings": decode_vlen_strings,
		# "driver": driver,
		# }
		driver_kwds = kwargs.pop("driver_kwds", None)
		if driver_kwds is not None:
		kwargs.update(driver_kwds)
		# check why this is needed in some cases, should not be in kwargs any more
		kwargs.pop("group", None)
		print("XX0:", kwargs)

		# if phony_dims is not None:
		# kwargs["phony_dims"] = phony_dims
		lock = store_kwargs.get("lock", None)
		if lock is None:
		if mode == "r":
		lock = HDF5_LOCK
		else:
		lock = combine_locks([HDF5_LOCK, get_write_lock(filename)])
		store_kwargs["lock"] = lock
		print("XX1:", store_kwargs)
		manager = CachingFileManager(h5netcdf.File, filename, mode=mode, kwargs=kwargs)
		return cls(manager, mode=mode, **store_kwargs)

Expand DownExpand Up		@@ -404,16 +393,6 @@ def _emit_phony_dims_warning():
		)


		from dataclasses import asdict, dataclass
		from typing import Optional

		from xarray.backends.locks import SerializableLock

		Buffer = Union[bytes, bytearray, memoryview]
		from xarray.backends.common import BackendOptions
		from xarray.backends.netCDF4_ import NetCDF4CoderOptions as H5netcdfCoderOptions


		@dataclass(frozen=True)
		class H5netcdfStoreOptions(BackendOptions):
		group: Optional[str] = None
Expand DownExpand Up		@@ -483,22 +462,6 @@ def open_dataset(
		filename_or_obj: str \| os.PathLike[Any] \| ReadBuffer \| AbstractDataStore,
		*,
		mode="r",
		# mask_and_scale=True,
		# decode_times=True,
		# concat_characters=True,
		# decode_coords=True,
		# drop_variables: str \| Iterable[str] \| None = None,
		# use_cftime=None,
		# decode_timedelta=None,
		# format=None,
		# group=None,
		# lock=None,
		# invalid_netcdf=None,
		# phony_dims=None,
		# decode_vlen_strings=True,
		# driver=None,
		# driver_kwds=None,
		# storage_options: dict[str, Any] \| None = None,
		coder_opts: H5netcdfCoderOptions = None,
		open_opts: H5netcdfOpenOptions = None,
		store_opts: H5netcdfStoreOptions = None,
Expand All		@@ -508,25 +471,12 @@ def open_dataset(
		open_opts = open_opts if open_opts is not None else self.open_opts
		store_opts = store_opts if store_opts is not None else self.store_opts

		# Keep this message for some versions
		# remove and set phony_dims="access" above
		# emit_phony_dims_warning, phony_dims = _check_phony_dims(phony_dims)

		filename_or_obj = _normalize_path(filename_or_obj)
		store = H5NetCDFStore.open(
		filename_or_obj,
		mode=mode,
		open_opts=open_opts,
		store_opts=store_opts,
		# format=format,
		# group=group,
		# lock=lock,
		# invalid_netcdf=invalid_netcdf,
		# phony_dims=phony_dims,
		# decode_vlen_strings=decode_vlen_strings,
		# driver=driver,
		# driver_kwds=driver_kwds,
		# storage_options=storage_options,
		**kwargs,
		)

Expand All		@@ -537,25 +487,8 @@ def open_dataset(
		coder_opts=coder_opts,
		)

		# only warn if phony_dims exist in file
		# remove together with the above check
		# after some versions
		# if store.ds._root._phony_dim_count > 0 and emit_phony_dims_warning:
		# _emit_phony_dims_warning()

		return ds

		# def to_netcdf(
		# self,
		# filename_or_obj: str \| os.PathLike[Any] \| ReadBuffer \| AbstractDataStore,
		# *,
		# coder_opts: H5netcdfCoderOptions = None,
		# open_opts: H5netcdfOpenOptions = None,
		# store_opts: H5netcdfStoreOptions = None,
		# **kwargs,
		# ):
		#

		def open_datatree(
		self,
		filename_or_obj: str \| os.PathLike[Any] \| ReadBuffer \| AbstractDataStore,
Expand Down