Upgrading xarray 2024 to 2025

Breaking2024.11.0 → 2025.12.0Breaking1New7Changed11Fixed17Other24

Full comparison Back to xarray

BreakingUpgrade verdict

1 breaking change.

In plain terms

This release undoes a change that had broken the default way Xarray reads and writes netCDF files.

Must act 1 item needs code or config changes

Python requirement changed in 2025.7.0: >=3.10 → >=3.11.

What you must change

Breaking1

Reverts a breaking change to Xarray's preferred netCDF backend.

2025.10.1GitHub ReleaseSummarizedView source

API changes

Generated by DepDelta from published Python source. Not mixed with prose notes.

added: export AlignmentError
added: export CoordinateValidationError
added: export coders
added: export indexes
added: export load_datatree

removed: function dump_to_store(dataset, store, writer=…, encoder=…, encoding=…, unlimited_dims=…)
removed: function save_mfdataset(datasets, paths, mode=…, format=…, groups=…, engine=…, compute=…, **kwargs)
removed: function to_netcdf(dataset: Dataset, path_or_file: str | os.PathLike | None=…, mode: NetcdfWriteModes=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Hashable, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, *, multifile: Literal[True], invalid_netcdf: bool=…, auto_complex: bool | None=…) -> tupl…
removed: function to_zarr(dataset: Dataset, store: MutableMapping | str | os.PathLike[str] | None=…, chunk_store: MutableMapping | str | os.PathLike | None=…, mode: ZarrWriteModes | None=…, synchronizer=…, group: str | None=…, encoding: Mapping | None=…, *, compute: Literal[True]=…, consolidated: bool | None=…, append_dim: Hashable | None=…, region: Mapping[str, slice | Literal['auto']] | Literal['auto']…
removed: variable ENGINES
removed: variable WRITEABLE_STORES: dict[T_NetcdfEngine, Callable]
changed: function load_dataarray(filename_or_obj, **kwargs) → function load_dataarray(filename_or_obj: T_PathFileOrDataStore, **kwargs) -> DataArray
changed: function load_dataset(filename_or_obj, **kwargs) -> Dataset → function load_dataset(filename_or_obj: T_PathFileOrDataStore, **kwargs) -> Dataset
changed: function open_dataarray(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, engine: T_Engine | None=…, chunks: T_Chunks | None=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | None=…, decode_times: bool | None=…, decode_timedelta: bool | None=…, use_cftime: bool | None=…, concat_characters: bool | None=…, decode_coords: Literal['coordinates', 'all… → function open_dataarray(filename_or_obj: T_PathFileOrDataStore, *, engine: T_Engine=…, chunks: T_Chunks=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | None=…, decode_times: bool | CFDatetimeCoder | Mapping[str, bool | CFDatetimeCoder] | None=…, decode_timedelta: bool | CFTimedeltaCoder | None=…, use_cftime: bool | None=…, concat_characters: bool | None=…, decode_coords:…
changed: function open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, engine: T_Engine=…, chunks: T_Chunks=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | Mapping[str, bool] | None=…, decode_times: bool | Mapping[str, bool] | None=…, decode_timedelta: bool | Mapping[str, bool] | None=…, use_cftime: bool | Mapping[str, bool] | None=…, concat_c… → function open_dataset(filename_or_obj: T_PathFileOrDataStore, *, engine: T_Engine=…, chunks: T_Chunks=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | Mapping[str, bool] | None=…, decode_times: bool | CFDatetimeCoder | Mapping[str, bool | CFDatetimeCoder] | None=…, decode_timedelta: bool | CFTimedeltaCoder | Mapping[str, bool | CFTimedeltaCoder] | None=…, use_cftime: bool…
changed: function open_datatree(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, engine: T_Engine=…, chunks: T_Chunks=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | Mapping[str, bool] | None=…, decode_times: bool | Mapping[str, bool] | None=…, decode_timedelta: bool | Mapping[str, bool] | None=…, use_cftime: bool | Mapping[str, bool] | None=…, concat_… → function open_datatree(filename_or_obj: T_PathFileOrDataStore, *, engine: T_Engine=…, chunks: T_Chunks=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | Mapping[str, bool] | None=…, decode_times: bool | CFDatetimeCoder | Mapping[str, bool | CFDatetimeCoder] | None=…, decode_timedelta: bool | CFTimedeltaCoder | Mapping[str, bool | CFTimedeltaCoder] | None=…, use_cftime: boo…
changed: function open_groups(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, engine: T_Engine=…, chunks: T_Chunks=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | Mapping[str, bool] | None=…, decode_times: bool | Mapping[str, bool] | None=…, decode_timedelta: bool | Mapping[str, bool] | None=…, use_cftime: bool | Mapping[str, bool] | None=…, concat_ch… → function open_groups(filename_or_obj: T_PathFileOrDataStore, *, engine: T_Engine=…, chunks: T_Chunks=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | Mapping[str, bool] | None=…, decode_times: bool | CFDatetimeCoder | Mapping[str, bool | CFDatetimeCoder] | None=…, decode_timedelta: bool | CFTimedeltaCoder | Mapping[str, bool | CFTimedeltaCoder] | None=…, use_cftime: bool…
changed: function open_mfdataset(paths: str | os.PathLike | ReadBuffer | NestedSequence[str | os.PathLike | ReadBuffer], chunks: T_Chunks | None=…, concat_dim: str | DataArray | Index | Sequence[str] | Sequence[DataArray] | Sequence[Index] | None=…, compat: CompatOptions=…, preprocess: Callable[[Dataset], Dataset] | None=…, engine: T_Engine | None=…, data_vars: Literal['all', 'minimal', 'different'] | lis… → function open_mfdataset(paths: str | os.PathLike | ReadBuffer | NestedSequence[str | os.PathLike | ReadBuffer], chunks: T_Chunks=…, concat_dim: str | DataArray | Index | Sequence[str] | Sequence[DataArray] | Sequence[Index] | None=…, compat: CompatOptions | CombineKwargDefault=…, preprocess: Callable[[Dataset], Dataset] | None=…, engine: T_Engine=…, data_vars: Literal['all', 'minimal', 'different…
added: function delayed_close_after_writes(writes, store)
added: function load_datatree(filename_or_obj: T_PathFileOrDataStore, **kwargs) -> DataTree

added: function align_nd_chunks(nd_v_chunks: tuple[tuple[int, ...], ...], nd_backend_chunks: tuple[tuple[int, ...], ...]) -> tuple[tuple[int, ...], ...]
added: function build_grid_chunks(size: int, chunk_size: int, region: slice | None=…) -> tuple[int, ...]
added: function grid_rechunk(v: Variable, enc_chunks: tuple[int, ...], region: tuple[slice, ...]) -> Variable
added: function validate_grid_chunks_alignment(nd_v_chunks: tuple[tuple[int, ...], ...] | None, enc_chunks: tuple[int, ...], backend_shape: tuple[int, ...], region: tuple[slice, ...], allow_partial_chunks: bool, name: str)

changed: method AbstractWritableDataStore.encode_variable(v) → method AbstractWritableDataStore.encode_variable(v, name=…)
changed: method AbstractWritableDataStore.set_dimension(dim, length) → method AbstractWritableDataStore.set_dimension(dim, length, is_unlimited)
changed: method BackendArray.get_duck_array(dtype: np.typing.DTypeLike=…) → method BackendArray.get_duck_array(dtype: np.typing.DTypeLike | None=…)
changed: method BackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool → method BackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | bytes | memoryview | AbstractDataStore) -> bool
changed: method BackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, drop_variables: str | Iterable[str] | None=…) -> Dataset → method BackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | bytes | memoryview | AbstractDataStore, *, drop_variables: str | Iterable[str] | None=…) -> Dataset
changed: method BackendEntrypoint.open_datatree(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, drop_variables: str | Iterable[str] | None=…) -> DataTree → method BackendEntrypoint.open_datatree(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | bytes | memoryview | AbstractDataStore, *, drop_variables: str | Iterable[str] | None=…) -> DataTree
changed: method BackendEntrypoint.open_groups_as_dict(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, drop_variables: str | Iterable[str] | None=…) -> dict[str, Dataset] → method BackendEntrypoint.open_groups_as_dict(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | bytes | memoryview | AbstractDataStore, *, drop_variables: str | Iterable[str] | None=…) -> dict[str, Dataset]
added: async method BackendArray.async_get_duck_array(dtype: np.typing.DTypeLike | None=…)
added: async method BackendArray.async_getitem(key: indexing.ExplicitIndexer) -> np.typing.ArrayLike
added: class BytesIOProxy
added: field BackendEntrypoint.supports_groups: ClassVar[bool]
added: field BytesIOProxy.getvalue: Callable[[], memoryview] | None
added: function collect_ancestor_dimensions(group) -> dict[str, int]
added: function ensure_dtype_not_object(var: Variable, name: T_Name=…) -> Variable
added: method AbstractDataStore.get_child_store(group: str) -> Self
added: method AbstractDataStore.get_parent_dimensions()
added: method AbstractWritableDataStore.prepare_variable(name, variable, check_encoding, unlimited_dims)
added: method AbstractWritableDataStore.sync()
added: method BytesIOProxy.getbuffer() -> memoryview
added: variable T_Name
added: variable T_PathFileOrDataStore

changed: class CachingFileManager(FileManager) → class CachingFileManager(FileManager[T_File])
changed: class DummyFileManager(FileManager) → class DummyFileManager(FileManager[T_File])
changed: class FileManager → class FileManager(Generic[T_File])
changed: constructor CachingFileManager(opener, *args, mode=…, kwargs=…, lock=…, cache=…, manager_id: Hashable | None=…, ref_counts=…) → constructor CachingFileManager(opener: Callable[..., T_File], *args: Any, mode: Any=…, kwargs: Mapping[str, Any] | None=…, lock: Lock | None | Literal[False]=…, cache: MutableMapping[Any, T_File] | None=…, manager_id: Hashable | None=…, ref_counts: dict[Any, int] | None=…)
changed: constructor DummyFileManager(value) → constructor DummyFileManager(value: T_File, *, close: Callable[[], None] | None=…)
changed: method CachingFileManager.acquire(needs_lock=…) → method CachingFileManager.acquire(needs_lock: bool=…) -> T_File
changed: method CachingFileManager.acquire_context(needs_lock=…) → method CachingFileManager.acquire_context(needs_lock: bool=…) -> Iterator[T_File]
changed: method CachingFileManager.close(needs_lock=…) → method CachingFileManager.close(needs_lock: bool=…) -> None
changed: method DummyFileManager.acquire(needs_lock=…) → method DummyFileManager.acquire(needs_lock: bool=…) -> T_File
changed: method DummyFileManager.acquire_context(needs_lock=…) → method DummyFileManager.acquire_context(needs_lock: bool=…) -> Iterator[T_File]
changed: method DummyFileManager.close(needs_lock=…) → method DummyFileManager.close(needs_lock: bool=…) -> None
changed: method FileManager.acquire(needs_lock=…) → method FileManager.acquire(needs_lock: bool=…) -> T_File
changed: method FileManager.acquire_context(needs_lock=…) → method FileManager.acquire_context(needs_lock: bool=…) -> AbstractContextManager[T_File]
changed: method FileManager.close(needs_lock=…) → method FileManager.close(needs_lock: bool=…) -> None
changed: variable FILE_CACHE: LRUCache[Any, io.IOBase] → variable FILE_CACHE: LRUCache[Any, Closable]
added: class PickleableFileManager(FileManager[T_File])
added: constructor PickleableFileManager(opener: Callable[..., T_File], *args: Any, mode: Any=…, kwargs: Mapping[str, Any] | None=…)
added: method PickleableFileManager.acquire(needs_lock: bool=…) -> T_File
added: method PickleableFileManager.acquire_context(needs_lock: bool=…) -> Iterator[T_File]
added: method PickleableFileManager.close(needs_lock: bool=…) -> None
added: variable T_File

changed: constructor H5NetCDFStore(manager, group=…, mode=…, lock=…, autoclose=…) → constructor H5NetCDFStore(manager: FileManager | h5netcdf.File | h5netcdf.Group, group=…, mode=…, format=…, lock=…, autoclose=…)
changed: method H5NetCDFStore.encode_variable(variable) → method H5NetCDFStore.encode_variable(variable, name=…)
changed: method H5netcdfBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool → method H5netcdfBackendEntrypoint.guess_can_open(filename_or_obj: T_PathFileOrDataStore) -> bool
changed: method H5netcdfBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, format=…, group=…, lock=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=…, storage_options:… → method H5netcdfBackendEntrypoint.open_dataset(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, format=…, group=…, lock=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=…, storage_options: dict[str, Any] | None=…) -> Dataset
changed: method H5netcdfBackendEntrypoint.open_datatree(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, format=…, group: str | None=…, lock=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=…, **kw… → method H5netcdfBackendEntrypoint.open_datatree(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, format=…, group: str | None=…, lock=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=…, **kwargs) -> DataTree
changed: method H5netcdfBackendEntrypoint.open_groups_as_dict(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, format=…, group: str | None=…, lock=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=…… → method H5netcdfBackendEntrypoint.open_groups_as_dict(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, format=…, group: str | None=…, lock=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=…, **kwargs) -> dict[str, Dataset]
added: field H5netcdfBackendEntrypoint.supports_groups
added: method H5NetCDFStore.get_child_store(group: str) -> Self
added: method H5NetCDFStore.get_parent_dimensions()

changed: class CombinedLock → class CombinedLock(Lock)
changed: class DummyLock → class DummyLock(Lock)
changed: class SerializableLock → class SerializableLock(Lock)
changed: constructor CombinedLock(locks) → constructor CombinedLock(locks: Sequence[Lock])
changed: function combine_locks(locks) → function combine_locks(locks: Sequence[Lock]) -> Lock
changed: function ensure_lock(lock) → function ensure_lock(lock: Lock | None | Literal[False]) -> Lock
changed: function get_write_lock(key) → function get_write_lock(key: str) -> Lock
added: function get_dask_scheduler(get=…, collection=…) -> str | None

changed: method NetCDF4BackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool → method NetCDF4BackendEntrypoint.guess_can_open(filename_or_obj: T_PathFileOrDataStore) -> bool
changed: method NetCDF4BackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group=…, mode=…, format=…, clobber=…, diskless=…, persist=…, auto_complex=…, lock=…, autoclose=…) -> Dataset → method NetCDF4BackendEntrypoint.open_dataset(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group=…, mode=…, format=…, clobber=…, diskless=…, persist=…, auto_complex=…, lock=…, autoclose=…) -> Dataset
changed: method NetCDF4BackendEntrypoint.open_datatree(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, format=…, clobber=…, diskless=…, persist=…, auto_complex=…, lock=…, autoclose=…, **kwargs) -> DataTree → method NetCDF4BackendEntrypoint.open_datatree(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, format=…, clobber=…, diskless=…, persist=…, auto_complex=…, lock=…, autoclose=…, **kwargs) -> DataTree
changed: method NetCDF4BackendEntrypoint.open_groups_as_dict(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, format=…, clobber=…, diskless=…, persist=…, auto_complex=…, lock=…, autoclose=…, **kwargs) -> dic… → method NetCDF4BackendEntrypoint.open_groups_as_dict(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, format=…, clobber=…, diskless=…, persist=…, auto_complex=…, lock=…, autoclose=…, **kwargs) -> dict[str, Dataset]
changed: method NetCDF4DataStore.encode_variable(variable) → method NetCDF4DataStore.encode_variable(variable, name=…)
added: field NetCDF4BackendEntrypoint.supports_groups
added: method NetCDF4DataStore.get_child_store(group: str) -> Self
added: method NetCDF4DataStore.get_parent_dimensions()

changed: function encode_nc3_variable(var) → function encode_nc3_variable(var, name=…)

removed: variable STANDARD_BACKENDS_ORDER
changed: function guess_engine(store_spec: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> str | type[BackendEntrypoint] → function guess_engine(store_spec: str | os.PathLike[Any] | ReadBuffer | bytes | memoryview | AbstractDataStore, must_support_groups: bool=…) -> str | type[BackendEntrypoint]

changed: constructor PydapArrayWrapper(array) → constructor PydapArrayWrapper(array, checksums=…)
changed: constructor PydapDataStore(ds) → constructor PydapDataStore(dataset, group=…, session=…, protocol=…, checksums=…)
changed: method PydapBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool → method PydapBackendEntrypoint.guess_can_open(filename_or_obj: T_PathFileOrDataStore) -> bool
changed: method PydapBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, application=…, session=…, output_grid=…, timeout=…, verify=…, user_charset=…) -> Dataset → method PydapBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | bytes | memoryview | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group=…, application=…, session=…, output_grid=…, timeout=…, verify=…, user_charset=…, checksums=…) -> Dat…
changed: static method PydapDataStore.open(url, application=…, session=…, output_grid=…, timeout=…, verify=…, user_charset=…) → static method PydapDataStore.open(url, group=…, application=…, session=…, output_grid=…, timeout=…, verify=…, user_charset=…, checksums=…)
added: function get_group(ds, group)
added: method PydapBackendEntrypoint.open_datatree(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, application=…, session=…, timeout=…, verify=…, user_charset=…, checksums=…) -> DataTree
added: method PydapBackendEntrypoint.open_groups_as_dict(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, application=…, session=…, timeout=…, verify=…, user_charset=…, checksums=…) -> dict[str, Dataset]
added: property PydapDataStore.ds

removed: property ScipyDataStore.ds
changed: method ScipyBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool → method ScipyBackendEntrypoint.guess_can_open(filename_or_obj: T_PathFileOrDataStore) -> bool
changed: method ScipyBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, mode=…, format=…, group=…, mmap=…, lock=…) -> Dataset → method ScipyBackendEntrypoint.open_dataset(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, mode=…, format=…, group=…, mmap=…, lock=…) -> Dataset
changed: method ScipyDataStore.encode_variable(variable) → method ScipyDataStore.encode_variable(variable, name=…)
added: class flush_only_netcdf_file(netcdf_file_base)
added: method flush_only_netcdf_file.close()
added: property ScipyDataStore.ds -> scipy.io.netcdf_file
added: variable netcdf_file_base

changed: method StoreBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool → method StoreBackendEntrypoint.guess_can_open(filename_or_obj: T_PathFileOrDataStore) -> bool
changed: method StoreBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…) -> Dataset → method StoreBackendEntrypoint.open_dataset(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, set_indexes: bool=…, use_cftime=…, decode_timedelta=…) -> Dataset

added: function dump_to_store(dataset, store, writer=…, encoder=…, encoding=…, unlimited_dims=…)
added: function get_default_netcdf_write_engine(path_or_file: str | IOBase | None, format: T_NetcdfTypes | None) -> Literal['netcdf4', 'h5netcdf', 'scipy']
added: function get_writable_netcdf_store(target, engine: T_NetcdfEngine, *, format: T_NetcdfTypes | None, mode: NetcdfWriteModes, autoclose: bool, invalid_netcdf: bool, auto_complex: bool | None) -> AbstractWritableDataStore
added: function get_writable_zarr_store(store: ZarrStoreLike | None=…, *, chunk_store: MutableMapping | str | os.PathLike | None=…, mode: ZarrWriteModes | None=…, synchronizer=…, group: str | None=…, consolidated: bool | None=…, append_dim: Hashable | None=…, region: Mapping[str, slice | Literal['auto']] | Literal['auto'] | None=…, safe_chunks: bool=…, align_chunks: bool=…, storage_options: dict[str, st…
added: function save_mfdataset(datasets, paths, mode=…, format=…, groups=…, engine=…, compute=…, **kwargs)
added: function to_netcdf(dataset: Dataset, path_or_file: str | os.PathLike | None=…, mode: NetcdfWriteModes=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Hashable, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, *, multifile: Literal[True], invalid_netcdf: bool=…, auto_complex: bool | None=…) -> tupl…
added: function to_zarr(dataset: Dataset, store: ZarrStoreLike | None=…, chunk_store: MutableMapping | str | os.PathLike | None=…, mode: ZarrWriteModes | None=…, synchronizer=…, group: str | None=…, encoding: Mapping | None=…, *, compute: Literal[True]=…, consolidated: bool | None=…, append_dim: Hashable | None=…, region: Mapping[str, slice | Literal['auto']] | Literal['auto'] | None=…, safe_chunks: boo…
added: variable T_DataTreeNetcdfEngine
added: variable T_DataTreeNetcdfTypes
added: variable WRITEABLE_STORES: dict[T_NetcdfEngine, Callable]

changed: constructor ZarrStore(zarr_group, mode=…, consolidate_on_close=…, append_dim=…, write_region=…, safe_chunks=…, write_empty: bool | None=…, close_store_on_close: bool=…, use_zarr_fill_value_as_mask=…) → constructor ZarrStore(zarr_group, mode=…, consolidate_on_close=…, append_dim=…, write_region=…, safe_chunks=…, write_empty: bool | None=…, close_store_on_close: bool=…, use_zarr_fill_value_as_mask=…, align_chunks: bool=…, cache_members: bool=…)
changed: function extract_zarr_variable_encoding(variable, raise_on_invalid=…, name=…, *, safe_chunks=…, region=…, mode=…, shape=…) → function extract_zarr_variable_encoding(variable, raise_on_invalid=…, name=…, *, zarr_format: ZarrFormat)
changed: method ZarrBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool → method ZarrBackendEntrypoint.guess_can_open(filename_or_obj: T_PathFileOrDataStore) -> bool
changed: method ZarrBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group=…, mode=…, synchronizer=…, consolidated=…, chunk_store=…, storage_options=…, zarr_version=…, zarr_format=…, store=…, engin… → method ZarrBackendEntrypoint.open_dataset(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group=…, mode=…, synchronizer=…, consolidated=…, chunk_store=…, storage_options=…, zarr_version=…, zarr_format=…, store=…, engine=…, use_zarr_fill_value_as_mask=……
changed: method ZarrBackendEntrypoint.open_datatree(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, mode=…, synchronizer=…, consolidated=…, chunk_store=…, storage_options=…, zarr_version=…, zarr_format=…) -… → method ZarrBackendEntrypoint.open_datatree(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, mode=…, synchronizer=…, consolidated=…, chunk_store=…, storage_options=…, zarr_version=…, zarr_format=…) -> DataTree
changed: method ZarrBackendEntrypoint.open_groups_as_dict(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, mode=…, synchronizer=…, consolidated=…, chunk_store=…, storage_options=…, zarr_version=…, zarr_forma… → method ZarrBackendEntrypoint.open_groups_as_dict(filename_or_obj: T_PathFileOrDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, mode=…, synchronizer=…, consolidated=…, chunk_store=…, storage_options=…, zarr_version=…, zarr_format=…) -> dict[str, Dataset]
changed: method ZarrStore.encode_variable(variable) → method ZarrStore.encode_variable(variable, name=…)
changed: method ZarrStore.open_store_variable(name, zarr_array=…) → method ZarrStore.open_store_variable(name)
changed: method ZarrStore.set_variables(variables, check_encoding_set, writer, unlimited_dims=…) → method ZarrStore.set_variables(variables: dict[str, Variable], check_encoding_set, writer, unlimited_dims=…)
changed: method ZarrStore.sync() → method ZarrStore.sync() -> None
changed: static method ZarrStore.open_group(store, mode: ZarrWriteModes=…, synchronizer=…, group=…, consolidated=…, consolidate_on_close=…, chunk_store=…, storage_options=…, append_dim=…, write_region=…, safe_chunks=…, zarr_version=…, zarr_format=…, use_zarr_fill_value_as_mask=…, write_empty: bool | None=…) → static method ZarrStore.open_group(store, mode: ZarrWriteModes=…, synchronizer=…, group=…, consolidated=…, consolidate_on_close=…, chunk_store=…, storage_options=…, append_dim=…, write_region=…, safe_chunks=…, align_chunks=…, zarr_version=…, zarr_format=…, use_zarr_fill_value_as_mask=…, write_empty: bool | None=…, cache_members: bool=…)
changed: static method ZarrStore.open_store(store, mode: ZarrWriteModes=…, synchronizer=…, group=…, consolidated=…, consolidate_on_close=…, chunk_store=…, storage_options=…, append_dim=…, write_region=…, safe_chunks=…, zarr_version=…, zarr_format=…, use_zarr_fill_value_as_mask=…, write_empty: bool | None=…) → static method ZarrStore.open_store(store, mode: ZarrWriteModes=…, synchronizer=…, group=…, consolidated=…, consolidate_on_close=…, chunk_store=…, storage_options=…, append_dim=…, write_region=…, safe_chunks=…, align_chunks=…, zarr_version=…, zarr_format=…, use_zarr_fill_value_as_mask=…, write_empty: bool | None=…, cache_members: bool=…)
added: async method ZarrArrayWrapper.async_getitem(key)
added: field ZarrBackendEntrypoint.supports_groups
added: function has_zarr_async_index() -> bool
added: method ZarrStore.array_keys() -> tuple[str, ...]
added: method ZarrStore.arrays() -> tuple[tuple[str, ZarrArray], ...]
added: method ZarrStore.get_child_store(group: str) -> Self
added: property ZarrStore.members -> dict[str, ZarrArray | ZarrGroup]

added: export CFDatetimeCoder
added: export CFTimedeltaCoder

removed: method Day.as_timedelta() -> timedelta
changed: class Day(Tick) → class Day(BaseCFTimeOffset)
changed: function cftime_range(start=…, end=…, periods=…, freq=…, normalize=…, name=…, closed: NoDefault | SideOptions=…, inclusive: None | InclusiveOptions=…, calendar=…) -> CFTimeIndex → function cftime_range(start=…, end=…, periods=…, freq=…, normalize=…, name=…, inclusive: InclusiveOptions=…, calendar=…) -> CFTimeIndex
changed: function date_range(start=…, end=…, periods=…, freq=…, tz=…, normalize=…, name=…, closed: NoDefault | SideOptions=…, inclusive: None | InclusiveOptions=…, calendar=…, use_cftime=…) → function date_range(start=…, end=…, periods=…, freq=…, tz=…, normalize=…, name=…, inclusive: InclusiveOptions=…, unit: PDDatetimeUnitOptions=…, calendar=…, use_cftime=…)
added: method Day.onOffset(date) -> bool

removed: function build_pattern(date_sep=…, datetime_sep=…, time_sep=…)
removed: function named(name, pattern)
removed: function optional(x)
removed: function parse_iso8601_like(datetime_string)
removed: function trailing_optional(xs)
changed: method CFTimeIndex.to_datetimeindex(unsafe=…) → method CFTimeIndex.to_datetimeindex(unsafe: bool=…, time_unit: PDDatetimeUnitOptions | None=…) -> pd.DatetimeIndex

added: class SerializationWarning(RuntimeWarning)
added: class VariableCoder
added: function lazy_elemwise_func(array, func: Callable, dtype: np.typing.DTypeLike | None)
added: function pop_to(source: MutableMapping, dest: MutableMapping, key: Hashable, name: T_Name=…) -> Any
added: function safe_setitem(dest, key: Hashable, value, name: T_Name=…)
added: function unpack_for_decoding(var: Variable) -> T_VarTuple
added: function unpack_for_encoding(var: Variable) -> T_VarTuple
added: method VariableCoder.decode(variable: Variable, name: T_Name=…) -> Variable
added: method VariableCoder.encode(variable: Variable, name: T_Name=…) -> Variable
added: variable T_Name
added: variable T_VarTuple

added: function validate_char_dim_name(strlen, encoding, name) -> str
added: method StackedBytesArray.get_duck_array()

removed: function to_timedelta_unboxed(value, **kwargs)
changed: constructor CFDatetimeCoder(use_cftime: bool | None=…) -> None → constructor CFDatetimeCoder(use_cftime: bool | None=…, time_unit: PDDatetimeUnitOptions=…) -> None
changed: function cftime_to_nptime(times, raise_on_invalid: bool=…) -> np.ndarray → function cftime_to_nptime(times, raise_on_invalid: bool=…, time_unit: PDDatetimeUnitOptions=…) -> np.ndarray
changed: function decode_cf_datetime(num_dates, units: str, calendar: str | None=…, use_cftime: bool | None=…) -> np.ndarray → function decode_cf_datetime(num_dates, units: str, calendar: str | None=…, use_cftime: bool | None=…, time_unit: PDDatetimeUnitOptions=…) -> np.ndarray
changed: function decode_cf_timedelta(num_timedeltas, units: str) -> np.ndarray → function decode_cf_timedelta(num_timedeltas, units: str, time_unit: PDDatetimeUnitOptions=…) -> np.ndarray
added: constructor CFTimedeltaCoder(time_unit: PDDatetimeUnitOptions | None=…, decode_via_units: bool=…, decode_via_dtype: bool=…) -> None
added: function build_pattern(date_sep: str=…, datetime_sep: str=…, time_sep: str=…, micro_sep: str=…) -> str
added: function has_timedelta64_encoding_dtype(attrs_or_encoding: dict) -> bool
added: function named(name: str, pattern: str) -> str
added: function optional(x: str) -> str
added: function parse_iso8601_like(datetime_string: str) -> dict[str, str | None]
added: function resolve_time_unit_from_attrs_dtype(attrs_dtype: str, name: T_Name) -> PDDatetimeUnitOptions
added: function trailing_optional(xs: list[str]) -> str

removed: class SerializationWarning(RuntimeWarning)
removed: class VariableCoder
removed: function lazy_elemwise_func(array, func: Callable, dtype: np.typing.DTypeLike)
removed: function pop_to(source: MutableMapping, dest: MutableMapping, key: Hashable, name: T_Name=…) -> Any
removed: function safe_setitem(dest, key: Hashable, value, name: T_Name=…)
removed: function unpack_for_decoding(var: Variable) -> T_VarTuple
removed: function unpack_for_encoding(var: Variable) -> T_VarTuple
removed: method VariableCoder.decode(variable: Variable, name: T_Name=…) -> Variable
removed: method VariableCoder.encode(variable: Variable, name: T_Name=…) -> Variable
added: constructor CFMaskCoder(decode_times: bool | CFDatetimeCoder=…, decode_timedelta: bool | CFTimedeltaCoder=…) -> None
added: constructor CFScaleOffsetCoder(decode_times: bool | CFDatetimeCoder=…, decode_timedelta: bool | CFTimedeltaCoder=…) -> None
added: method BoolTypeArray.get_duck_array()
added: method BoolTypeArray.transpose(order)
added: method NativeEndiannessArray.get_duck_array()
added: method NativeEndiannessArray.transpose(order)

added: function get_array_namespace(*values)
added: function is_weak_scalar_type(t)
added: function result_type(*arrays_and_dtypes, xp) -> np.dtype
added: function to_like_array(array, like)

added: function reshape_blockwise(x: Any, shape: int | tuple[int, ...], chunks: tuple[tuple[int, ...], ...] | None=…)
added: function sliding_window_view(x, window_shape, axis=…, *, automatic_rechunk=…, **kwargs)

added: function dask_rolling_wrapper(moving_func, a, window, min_count=…, axis=…)
added: function least_squares(lhs, rhs, rcond=…, skipna=…)
added: function push(array, n, axis, method=…)

added: function isdtype(dtype: np.dtype[Any] | type[Any], kind: DTypeLike | tuple[DTypeLike, ...]) -> bool
added: variable HAS_STRING_DTYPE
added: variable kind_mapping

added: function count_not_none(*args) -> int
added: function default_precision_timestamp(*args, **kwargs) -> pd.Timestamp
added: function timestamp_as_unit(date: pd.Timestamp, unit: PDDatetimeUnitOptions) -> pd.Timestamp
added: variable NoDefault
added: variable no_default

added: function sliding_window(n, seq)

added: function apply_array_ufunc(func, *args, dask=…)
added: function apply_dataarray_vfunc(func, *args, signature: _UFuncSignature, join: JoinOptions=…, exclude_dims=…, keep_attrs=…) -> tuple[DataArray, ...] | DataArray
added: function apply_dataset_vfunc(func, *args, signature: _UFuncSignature, join=…, dataset_join=…, fill_value=…, exclude_dims=…, keep_attrs=…, on_missing_core_dim: MissingCoreDimOptions=…) -> Dataset | tuple[Dataset, ...]
added: function apply_dict_of_variables_vfunc(func, *args, signature: _UFuncSignature, join=…, fill_value=…, on_missing_core_dim: MissingCoreDimOptions=…)
added: function apply_groupby_func(func, *args)
added: function apply_ufunc(func: Callable, *args: Any, input_core_dims: Sequence[Sequence] | None=…, output_core_dims: Sequence[Sequence] | None=…, exclude_dims: AbstractSet=…, vectorize: bool=…, join: JoinOptions=…, dataset_join: str=…, dataset_fill_value: object=…, keep_attrs: bool | str | None=…, kwargs: Mapping | None=…, dask: Literal['forbidden', 'allowed', 'parallelized']=…, output_dtypes: Sequen…
added: function apply_variable_ufunc(func, *args, signature: _UFuncSignature, exclude_dims=…, dask=…, output_dtypes=…, vectorize=…, keep_attrs=…, dask_gufunc_kwargs=…) -> Variable | tuple[Variable, ...]
added: function assert_and_return_exact_match(all_keys)
added: function broadcast_compat_data(variable: Variable, broadcast_dims: tuple[Hashable, ...], core_dims: tuple[Hashable, ...]) -> Any
added: function build_output_coords_and_indexes(args: Iterable[Any], signature: _UFuncSignature, exclude_dims: AbstractSet=…, combine_attrs: CombineAttrsOptions=…) -> tuple[list[dict[Any, Variable]], list[dict[Any, Index]]]
added: function collect_dict_values(objects: Iterable[Mapping | Any], keys: Iterable, fill_value: object=…) -> list[list]
added: function join_dict_keys(objects: Iterable[Mapping | Any], how: str=…) -> Iterable
added: function ordered_set_intersection(all_keys: list[Iterable]) -> Iterable
added: function ordered_set_union(all_keys: list[Iterable]) -> Iterable
added: function unified_dim_sizes(variables: Iterable[Variable], exclude_dims: AbstractSet=…) -> dict[Hashable, int]
added: variable MissingCoreDimOptions
added: variable SLICE_NONE

added: class CoarsenArithmetic(IncludeReduceMethods)
added: class DataArrayArithmetic(ImplementsArrayReduce, IncludeNumpySameMethods, SupportsArithmetic, DataArrayOpsMixin)
added: class DataArrayGroupbyArithmetic(SupportsArithmetic, DataArrayGroupByOpsMixin)
added: class DatasetArithmetic(ImplementsDatasetReduce, SupportsArithmetic, DatasetOpsMixin)
added: class DatasetGroupbyArithmetic(SupportsArithmetic, DatasetGroupByOpsMixin)
added: class SupportsArithmetic
added: class VariableArithmetic(ImplementsArrayReduce, IncludeNumpySameMethods, SupportsArithmetic, VariableOpsMixin)

added: function corr(da_a: T_DataArray, da_b: T_DataArray, dim: Dims=…, weights: T_DataArray | None=…) -> T_DataArray
added: function cov(da_a: T_DataArray, da_b: T_DataArray, dim: Dims=…, ddof: int=…, weights: T_DataArray | None=…) -> T_DataArray
added: function cross(a: DataArray | Variable, b: DataArray | Variable, *, dim: Hashable) -> DataArray | Variable
added: function dot(*arrays, dim: Dims=…, **kwargs: Any)
added: function polyval(coord: DataArray, coeffs: DataArray, degree_dim: Hashable=…) -> DataArray | (coord: DataArray, coeffs: Dataset, degree_dim: Hashable=…) -> Dataset | (coord: Dataset, coeffs: DataArray, degree_dim: Hashable=…) -> Dataset | (coord: Dataset, coeffs: Dataset, degree_dim: Hashable=…) -> Dataset | (coord: Dataset | DataArray, coeffs: Dataset | DataArray, degree_dim: Hashable=…) -> Data…
added: function where(cond, x, y, keep_attrs=…)
added: variable MissingCoreDimOptions

added: function curvefit(obj, coords: str | DataArray | Iterable[str | DataArray], func: Callable[..., Any], reduce_dims: Dims=…, skipna: bool=…, p0: Mapping[str, float | DataArray] | None=…, bounds: Mapping[str, tuple[float | DataArray, float | DataArray]] | None=…, param_names: Sequence[str] | None=…, errors: ErrorOptions=…, kwargs: dict[str, Any] | None=…)
added: function polyfit(obj, dim: Hashable, deg: int, skipna: bool | None=…, rcond: np.floating[Any] | float | None=…, w: Hashable | Any=…, full: bool=…, cov: bool | Literal['unscaled']=…)

added: function nanargmax(a, axis=…)
added: function nanargmin(a, axis=…)
added: function nancumprod(a, axis=…, dtype=…, out=…)
added: function nancumsum(a, axis=…, dtype=…, out=…)
added: function nanmax(a, axis=…, out=…)
added: function nanmean(a, axis=…, dtype=…, out=…)
added: function nanmedian(a, axis=…, out=…)
added: function nanmin(a, axis=…, out=…)
added: function nanprod(a, axis=…, dtype=…, out=…, min_count=…)
added: function nanstd(a, axis=…, dtype=…, out=…, ddof=…)
added: function nansum(a, axis=…, dtype=…, out=…, min_count=…)
added: function nanvar(a, axis=…, dtype=…, out=…, ddof=…)

added: class IncludeNumpySameMethods
added: class IncludeReduceMethods
added: function fillna(data, other, join=…, dataset_join=…)
added: function get_op(name)
added: function inject_numpy_same(cls)
added: function inject_reduce_methods(cls)
added: function inplace_to_noninplace_op(f)
added: function op_str(name)
added: function where_method(self, cond, other=…)
added: variable NAN_REDUCE_METHODS
added: variable NON_INPLACE_OP
added: variable NUMPY_SAME_METHODS
added: variable NUM_BINARY_OPS
added: variable REDUCE_METHODS
added: variable argsort
added: variable bn
added: variable conj
added: variable conjugate
added: variable has_bottleneck
added: variable round_

added: class Coarsen(CoarsenArithmetic, Generic[T_Xarray])
added: class DataArrayCoarsen(Coarsen['DataArray'])
added: class DataArrayRolling(Rolling['DataArray'])
added: class DatasetCoarsen(Coarsen['Dataset'])
added: class DatasetRolling(Rolling['Dataset'])
added: class Rolling(Generic[T_Xarray])
added: constructor Coarsen(obj: T_Xarray, windows: Mapping[Any, int], boundary: CoarsenBoundaryOptions, side: SideOptions | Mapping[Any, SideOptions], coord_func: str | Callable | Mapping[Any, str | Callable]) -> None
added: constructor DataArrayRolling(obj: DataArray, windows: Mapping[Any, int], min_periods: int | None=…, center: bool | Mapping[Any, bool]=…) -> None
added: constructor DatasetRolling(obj: Dataset, windows: Mapping[Any, int], min_periods: int | None=…, center: bool | Mapping[Any, bool]=…) -> None
added: constructor Rolling(obj: T_Xarray, windows: Mapping[Any, int], min_periods: int | None=…, center: bool | Mapping[Any, bool]=…) -> None
added: field Coarsen.boundary: CoarsenBoundaryOptions
added: field Coarsen.coord_func: Mapping[Hashable, str | Callable]
added: field Coarsen.obj: T_Xarray
added: field Coarsen.side: SideOptions | Mapping[Hashable, SideOptions]
added: field Coarsen.windows: Mapping[Hashable, int]
added: field Rolling.argmax
added: field Rolling.argmin
added: field Rolling.center: list[bool]
added: field Rolling.dim: list[Hashable]
added: field Rolling.max
added: field Rolling.mean
added: field Rolling.median
added: field Rolling.min
added: field Rolling.min_periods: int
added: field Rolling.obj: T_Xarray
added: field Rolling.prod
added: field Rolling.std
added: field Rolling.sum
added: field Rolling.var
added: field Rolling.window: list[int]
added: method Coarsen.construct(window_dim=…, keep_attrs=…, **window_dim_kwargs) -> T_Xarray
added: method DataArrayCoarsen.reduce(func: Callable, keep_attrs: bool | None=…, **kwargs) -> DataArray
added: method DataArrayRolling.construct(window_dim: Hashable | Mapping[Any, Hashable] | None=…, *, stride: int | Mapping[Any, int]=…, fill_value: Any=…, keep_attrs: bool | None=…, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **window_dim_kwargs: Hashable) -> DataArray
added: method DataArrayRolling.reduce(func: Callable, keep_attrs: bool | None=…, *, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **kwargs: Any) -> DataArray
added: method DatasetCoarsen.reduce(func: Callable, keep_attrs=…, **kwargs) -> Dataset
added: method DatasetRolling.construct(window_dim: Hashable | Mapping[Any, Hashable] | None=…, *, stride: int | Mapping[Any, int]=…, fill_value: Any=…, keep_attrs: bool | None=…, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **window_dim_kwargs: Hashable) -> Dataset
added: method DatasetRolling.reduce(func: Callable, keep_attrs: bool | None=…, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **kwargs: Any) -> DataArray
added: method Rolling.count(keep_attrs: bool | None=…) -> T_Xarray
added: property Rolling.ndim -> int
added: variable RollingKey
added: variable bottleneck

added: class RollingExp(Generic[T_DataWithCoords])
added: constructor RollingExp(obj: T_DataWithCoords, windows: Mapping[Any, int | float], window_type: str=…, min_weight: float=…)
added: method RollingExp.corr(other: T_DataWithCoords) -> T_DataWithCoords
added: method RollingExp.cov(other: T_DataWithCoords) -> T_DataWithCoords
added: method RollingExp.mean(keep_attrs: bool | None=…) -> T_DataWithCoords
added: method RollingExp.std() -> T_DataWithCoords
added: method RollingExp.sum(keep_attrs: bool | None=…) -> T_DataWithCoords
added: method RollingExp.var() -> T_DataWithCoords

added: class DataArrayWeighted(Weighted['DataArray'])
added: class DatasetWeighted(Weighted['Dataset'])
added: class Weighted(Generic[T_Xarray])
added: constructor Weighted(obj: T_Xarray, weights: T_DataArray) -> None
added: method Weighted.mean(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
added: method Weighted.quantile(q: ArrayLike, *, dim: Dims=…, keep_attrs: bool | None=…, skipna: bool=…) -> T_Xarray
added: method Weighted.std(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
added: method Weighted.sum(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
added: method Weighted.sum_of_squares(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
added: method Weighted.sum_of_weights(dim: Dims=…, *, keep_attrs: bool | None=…) -> T_Xarray
added: method Weighted.var(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
added: variable QUANTILE_METHODS

removed: function ensure_dtype_not_object(var: Variable, name: T_Name=…) -> Variable
changed: function cf_decoder(variables: T_Variables, attributes: T_Attrs, concat_characters: bool=…, mask_and_scale: bool=…, decode_times: bool=…) -> tuple[T_Variables, T_Attrs] → function cf_decoder(variables: T_Variables, attributes: T_Attrs, concat_characters: bool=…, mask_and_scale: bool=…, decode_times: bool | CFDatetimeCoder | Mapping[str, bool | CFDatetimeCoder]=…) -> tuple[T_Variables, T_Attrs]
changed: function decode_cf(obj: T_DatasetOrAbstractstore, concat_characters: bool=…, mask_and_scale: bool=…, decode_times: bool=…, decode_coords: bool | Literal['coordinates', 'all']=…, drop_variables: T_DropVariables=…, use_cftime: bool | None=…, decode_timedelta: bool | None=…) -> Dataset → function decode_cf(obj: T_DatasetOrAbstractstore, concat_characters: bool=…, mask_and_scale: bool=…, decode_times: bool | CFDatetimeCoder | Mapping[str, bool | CFDatetimeCoder]=…, decode_coords: bool | Literal['coordinates', 'all']=…, drop_variables: T_DropVariables=…, use_cftime: bool | None=…, decode_timedelta: bool | CFTimedeltaCoder | Mapping[str, bool | CFTimedeltaCoder] | None=…) -> Dataset
changed: function decode_cf_variable(name: Hashable, var: Variable, concat_characters: bool=…, mask_and_scale: bool=…, decode_times: bool=…, decode_endianness: bool=…, stack_char_dim: bool=…, use_cftime: bool | None=…, decode_timedelta: bool | None=…) -> Variable → function decode_cf_variable(name: Hashable, var: Variable, concat_characters: bool=…, mask_and_scale: bool=…, decode_times: bool | CFDatetimeCoder=…, decode_endianness: bool=…, stack_char_dim: bool=…, use_cftime: bool | None=…, decode_timedelta: bool | CFTimedeltaCoder | None=…) -> Variable
changed: function decode_cf_variables(variables: T_Variables, attributes: T_Attrs, concat_characters: bool | Mapping[str, bool]=…, mask_and_scale: bool | Mapping[str, bool]=…, decode_times: bool | Mapping[str, bool]=…, decode_coords: bool | Literal['coordinates', 'all']=…, drop_variables: T_DropVariables=…, use_cftime: bool | Mapping[str, bool] | None=…, decode_timedelta: bool | Mapping[str, bool] | None=… → function decode_cf_variables(variables: T_Variables, attributes: T_Attrs, concat_characters: bool | Mapping[str, bool]=…, mask_and_scale: bool | Mapping[str, bool]=…, decode_times: bool | CFDatetimeCoder | Mapping[str, bool | CFDatetimeCoder]=…, decode_coords: bool | Literal['coordinates', 'all']=…, drop_variables: T_DropVariables=…, use_cftime: bool | Mapping[str, bool] | None=…, decode_timedelt…
added: variable U

removed: class Aligner(Generic[T_Alignable])
removed: constructor Aligner(objects: Iterable[T_Alignable], join: str=…, indexes: Mapping[Any, Any] | None=…, exclude_dims: str | Iterable[Hashable]=…, exclude_vars: Iterable[Hashable]=…, method: str | None=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value: Any=…, sparse: bool=…)
removed: field Aligner.aligned_index_vars: dict[MatchingIndexKey, dict[Hashable, Variable]]
removed: field Aligner.aligned_indexes: dict[MatchingIndexKey, Index]
removed: field Aligner.all_index_vars: dict[MatchingIndexKey, list[dict[Hashable, Variable]]]
removed: field Aligner.all_indexes: dict[MatchingIndexKey, list[Index]]
removed: field Aligner.copy: bool
removed: field Aligner.exclude_dims: frozenset[Hashable]
removed: field Aligner.exclude_vars: frozenset[Hashable]
removed: field Aligner.fill_value: Any
removed: field Aligner.index_vars: dict[MatchingIndexKey, dict[Hashable, Variable]]
removed: field Aligner.indexes: dict[MatchingIndexKey, Index]
removed: field Aligner.join: str
removed: field Aligner.new_indexes: Indexes[Index]
removed: field Aligner.objects: tuple[T_Alignable, ...]
removed: field Aligner.objects_matching_indexes: tuple[dict[MatchingIndexKey, Index], ...]
removed: field Aligner.reindex: dict[MatchingIndexKey, bool]
removed: field Aligner.reindex_kwargs: dict[str, Any]
removed: field Aligner.results: tuple[T_Alignable, ...]
removed: field Aligner.sparse: bool
removed: field Aligner.unindexed_dim_sizes: dict[Hashable, set]
removed: function align(obj1: T_Obj1, /, *, join: JoinOptions=…, copy: bool=…, indexes=…, exclude: str | Iterable[Hashable]=…, fill_value=…) -> tuple[T_Obj1] | (obj1: T_Obj1, obj2: T_Obj2, /, *, join: JoinOptions=…, copy: bool=…, indexes=…, exclude: str | Iterable[Hashable]=…, fill_value=…) -> tuple[T_Obj1, T_Obj2] | (obj1: T_Obj1, obj2: T_Obj2, obj3: T_Obj3, /, *, join: JoinOptions=…, copy: bool=…, index…
removed: function broadcast(obj1: T_Obj1, /, *, exclude: str | Iterable[Hashable] | None=…) -> tuple[T_Obj1] | (obj1: T_Obj1, obj2: T_Obj2, /, *, exclude: str | Iterable[Hashable] | None=…) -> tuple[T_Obj1, T_Obj2] | (obj1: T_Obj1, obj2: T_Obj2, obj3: T_Obj3, /, *, exclude: str | Iterable[Hashable] | None=…) -> tuple[T_Obj1, T_Obj2, T_Obj3] | (obj1: T_Obj1, obj2: T_Obj2, obj3: T_Obj3, obj4: T_Obj4, /, *,…
removed: function deep_align(objects: Iterable[Any], join: JoinOptions=…, copy: bool=…, indexes=…, exclude: str | Iterable[Hashable]=…, raise_on_invalid: bool=…, fill_value=…) -> list[Any]
removed: function reindex(obj: T_Alignable, indexers: Mapping[Any, Any], method: str | None=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value: Any=…, sparse: bool=…, exclude_vars: Iterable[Hashable]=…) -> T_Alignable
removed: function reindex_like(obj: T_Alignable, other: Dataset | DataArray, method: str | None=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value: Any=…) -> T_Alignable
removed: function reindex_variables(variables: Mapping[Any, Variable], dim_pos_indexers: Mapping[Any, Any], copy: bool=…, fill_value: Any=…, sparse: bool=…) -> dict[Hashable, Variable]
removed: method Aligner.align() -> None
removed: method Aligner.align_indexes() -> None
removed: method Aligner.assert_no_index_conflict() -> None
removed: method Aligner.assert_unindexed_dim_sizes_equal() -> None
removed: method Aligner.find_matching_indexes() -> None
removed: method Aligner.find_matching_unindexed_dims() -> None
removed: method Aligner.override_indexes() -> None
removed: method Aligner.reindex_all() -> None
removed: variable CoordNamesAndDims
removed: variable MatchingIndexKey
removed: variable NormalizedIndexVars
removed: variable NormalizedIndexes
removed: variable T_Obj1
removed: variable T_Obj2
removed: variable T_Obj3
removed: variable T_Obj4
removed: variable T_Obj5

removed: class CoarsenArithmetic(IncludeReduceMethods)
removed: class DataArrayArithmetic(ImplementsArrayReduce, IncludeNumpySameMethods, SupportsArithmetic, DataArrayOpsMixin)
removed: class DataArrayGroupbyArithmetic(SupportsArithmetic, DataArrayGroupByOpsMixin)
removed: class DatasetArithmetic(ImplementsDatasetReduce, SupportsArithmetic, DatasetOpsMixin)
removed: class DatasetGroupbyArithmetic(SupportsArithmetic, DatasetGroupByOpsMixin)
removed: class SupportsArithmetic
removed: class VariableArithmetic(ImplementsArrayReduce, IncludeNumpySameMethods, SupportsArithmetic, VariableOpsMixin)

removed: function is_weak_scalar_type(t)
removed: function result_type(*arrays_and_dtypes, xp) -> np.dtype

removed: function combine_by_coords(data_objects: Iterable[Dataset | DataArray]=…, compat: CompatOptions=…, data_vars: Literal['all', 'minimal', 'different'] | list[str]=…, coords: str=…, fill_value: object=…, join: JoinOptions=…, combine_attrs: CombineAttrsOptions=…) -> Dataset | DataArray
removed: function combine_nested(datasets: DATASET_HYPERCUBE, concat_dim: str | DataArray | None | Sequence[str | DataArray | pd.Index | None], compat: str=…, data_vars: str=…, coords: str=…, fill_value: object=…, join: JoinOptions=…, combine_attrs: CombineAttrsOptions=…) -> Dataset
removed: function vars_as_keys(ds)
removed: variable DATASET_HYPERCUBE
removed: variable T

changed: function is_np_datetime_like(dtype: DTypeLike) -> bool → function is_np_datetime_like(dtype: DTypeLike | None) -> bool
changed: function is_np_timedelta_like(dtype: DTypeLike) -> bool → function is_np_timedelta_like(dtype: DTypeLike | None) -> bool
changed: method AbstractArray.get_axis_num(dim: Iterable[Hashable]) -> tuple[int, ...] | (dim: Hashable) -> int → method AbstractArray.get_axis_num(dim: str) -> int | (dim: Iterable[Hashable]) -> tuple[int, ...] | (dim: Hashable) -> int
changed: method DataWithCoords.pipe(func: Callable[..., T] | tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T → method DataWithCoords.pipe(func: Callable[Concatenate[Self, P], T], *args: P.args, **kwargs: P.kwargs) -> T | (func: tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T
added: variable P

removed: function apply_array_ufunc(func, *args, dask=…)
removed: function apply_dataarray_vfunc(func, *args, signature: _UFuncSignature, join: JoinOptions=…, exclude_dims=…, keep_attrs=…) -> tuple[DataArray, ...] | DataArray
removed: function apply_dataset_vfunc(func, *args, signature: _UFuncSignature, join=…, dataset_join=…, fill_value=…, exclude_dims=…, keep_attrs=…, on_missing_core_dim: MissingCoreDimOptions=…) -> Dataset | tuple[Dataset, ...]
removed: function apply_dict_of_variables_vfunc(func, *args, signature: _UFuncSignature, join=…, fill_value=…, on_missing_core_dim: MissingCoreDimOptions=…)
removed: function apply_groupby_func(func, *args)
removed: function apply_ufunc(func: Callable, *args: Any, input_core_dims: Sequence[Sequence] | None=…, output_core_dims: Sequence[Sequence] | None=…, exclude_dims: Set=…, vectorize: bool=…, join: JoinOptions=…, dataset_join: str=…, dataset_fill_value: object=…, keep_attrs: bool | str | None=…, kwargs: Mapping | None=…, dask: Literal['forbidden', 'allowed', 'parallelized']=…, output_dtypes: Sequence | Non…
removed: function apply_variable_ufunc(func, *args, signature: _UFuncSignature, exclude_dims=…, dask=…, output_dtypes=…, vectorize=…, keep_attrs=…, dask_gufunc_kwargs=…) -> Variable | tuple[Variable, ...]
removed: function assert_and_return_exact_match(all_keys)
removed: function broadcast_compat_data(variable: Variable, broadcast_dims: tuple[Hashable, ...], core_dims: tuple[Hashable, ...]) -> Any
removed: function build_output_coords_and_indexes(args: Iterable[Any], signature: _UFuncSignature, exclude_dims: Set=…, combine_attrs: CombineAttrsOptions=…) -> tuple[list[dict[Any, Variable]], list[dict[Any, Index]]]
removed: function collect_dict_values(objects: Iterable[Mapping | Any], keys: Iterable, fill_value: object=…) -> list[list]
removed: function corr(da_a: T_DataArray, da_b: T_DataArray, dim: Dims=…, weights: T_DataArray | None=…) -> T_DataArray
removed: function cov(da_a: T_DataArray, da_b: T_DataArray, dim: Dims=…, ddof: int=…, weights: T_DataArray | None=…) -> T_DataArray
removed: function cross(a: DataArray | Variable, b: DataArray | Variable, *, dim: Hashable) -> DataArray | Variable
removed: function dot(*arrays, dim: Dims=…, **kwargs: Any)
removed: function join_dict_keys(objects: Iterable[Mapping | Any], how: str=…) -> Iterable
removed: function ordered_set_intersection(all_keys: list[Iterable]) -> Iterable
removed: function ordered_set_union(all_keys: list[Iterable]) -> Iterable
removed: function polyval(coord: DataArray, coeffs: DataArray, degree_dim: Hashable=…) -> DataArray | (coord: DataArray, coeffs: Dataset, degree_dim: Hashable=…) -> Dataset | (coord: Dataset, coeffs: DataArray, degree_dim: Hashable=…) -> Dataset | (coord: Dataset, coeffs: Dataset, degree_dim: Hashable=…) -> Dataset | (coord: Dataset | DataArray, coeffs: Dataset | DataArray, degree_dim: Hashable=…) -> Data…
removed: function unified_dim_sizes(variables: Iterable[Variable], exclude_dims: Set=…) -> dict[Hashable, int]
removed: function unify_chunks(__obj: _T) -> tuple[_T] | (__obj1: _T, __obj2: _U) -> tuple[_T, _U] | (__obj1: _T, __obj2: _U, __obj3: _V) -> tuple[_T, _U, _V] | (*objects: Dataset | DataArray) -> tuple[Dataset | DataArray, ...]
removed: function where(cond, x, y, keep_attrs=…)
removed: variable MissingCoreDimOptions
removed: variable SLICE_NONE

removed: function concat(objs: Iterable[T_Dataset], dim: Hashable | T_Variable | T_DataArray | pd.Index | Any, data_vars: T_DataVars=…, coords: ConcatOptions | list[Hashable]=…, compat: CompatOptions=…, positions: Iterable[Iterable[int]] | None=…, fill_value: object=…, join: JoinOptions=…, combine_attrs: CombineAttrsOptions=…, create_index_for_new_dim: bool=…) -> T_Dataset | (objs: Iterable[T_DataArray],…
removed: variable T_DataVars

added: class CoordinateTransform
added: constructor CoordinateTransform(coord_names: Iterable[Hashable], dim_size: Mapping[str, int], dtype: Any=…)
added: field CoordinateTransform.coord_names: tuple[Hashable, ...]
added: field CoordinateTransform.dim_size: dict[str, int]
added: field CoordinateTransform.dims: tuple[str, ...]
added: field CoordinateTransform.dtype: Any
added: method CoordinateTransform.equals(other: CoordinateTransform) -> bool | (other: CoordinateTransform, *, exclude: frozenset[Hashable] | None=…) -> bool
added: method CoordinateTransform.forward(dim_positions: dict[str, Any]) -> dict[Hashable, Any]
added: method CoordinateTransform.generate_coords(dims: tuple[str, ...] | None=…) -> dict[Hashable, Any]
added: method CoordinateTransform.reverse(coord_labels: dict[Hashable, Any]) -> dict[str, Any]

added: class CoordinateValidationError(ValueError)
added: function coordinates_from_variable(variable: Variable) -> Coordinates
added: function validate_dataarray_coords(shape: tuple[int, ...], coords: Coordinates | Mapping[Hashable, Variable], dim: tuple[Hashable, ...])
added: method Coordinates.drop_dims(drop_dims: str | Iterable[Hashable], *, errors: ErrorOptions=…) -> Self
added: method Coordinates.drop_vars(names: str | Iterable[Hashable] | Callable[[Coordinates | Dataset | DataArray | DataTree], str | Iterable[Hashable]], *, errors: ErrorOptions=…) -> Self
added: method Coordinates.rename_dims(dims_dict: Mapping[Any, Hashable] | None=…, **dims: Hashable) -> Self
added: method Coordinates.rename_vars(name_dict: Mapping[Any, Hashable] | None=…, **names: Hashable) -> Coordinates
added: static method Coordinates.from_xindex(index: Index) -> Self

removed: function reshape_blockwise(x: Any, shape: int | tuple[int, ...], chunks: tuple[tuple[int, ...], ...] | None=…)
removed: function sliding_window_view(x, window_shape, axis=…, *, automatic_rechunk=…, **kwargs)

removed: function dask_rolling_wrapper(moving_func, a, window, min_count=…, axis=…)
removed: function least_squares(lhs, rhs, rcond=…, skipna=…)
removed: function push(array, n, axis, method=…)

changed: method DataArray.expand_dims(dim: None | Hashable | Sequence[Hashable] | Mapping[Any, Any]=…, axis: None | int | Sequence[int]=…, create_index_for_new_dim: bool=…, **dim_kwargs: Any) -> Self → method DataArray.expand_dims(dim: Hashable | Sequence[Hashable] | Mapping[Any, Any] | None=…, axis: int | Sequence[int] | None=…, create_index_for_new_dim: bool=…, **dim_kwargs: Any) -> Self
changed: method DataArray.groupby(group: GroupInput=…, *, squeeze: Literal[False]=…, restore_coord_dims: bool=…, eagerly_compute_group: bool=…, **groupers: Grouper) -> DataArrayGroupBy → method DataArray.groupby(group: GroupInput=…, *, squeeze: Literal[False]=…, restore_coord_dims: bool=…, eagerly_compute_group: Literal[False] | None=…, **groupers: Grouper) -> DataArrayGroupBy
changed: method DataArray.groupby_bins(group: Hashable | DataArray | IndexVariable, bins: Bins, right: bool=…, labels: ArrayLike | Literal[False] | None=…, precision: int=…, include_lowest: bool=…, squeeze: Literal[False]=…, restore_coord_dims: bool=…, duplicates: Literal['raise', 'drop']=…, eagerly_compute_group: bool=…) -> DataArrayGroupBy → method DataArray.groupby_bins(group: Hashable | DataArray | IndexVariable, bins: Bins, right: bool=…, labels: ArrayLike | Literal[False] | None=…, precision: int=…, include_lowest: bool=…, squeeze: Literal[False]=…, restore_coord_dims: bool=…, duplicates: Literal['raise', 'drop']=…, eagerly_compute_group: Literal[False] | None=…) -> DataArrayGroupBy
changed: method DataArray.to_netcdf(path: None=…, mode: NetcdfWriteModes=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Hashable, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, invalid_netcdf: bool=…, auto_complex: bool | None=…) -> bytes | (path: str | PathLike, mode: NetcdfWriteModes=…, format: T_Netc… → method DataArray.to_netcdf(path: None=…, mode: NetcdfWriteModes=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Hashable, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, invalid_netcdf: bool=…, auto_complex: bool | None=…) -> memoryview | (path: str | PathLike, mode: NetcdfWriteModes=…, format: T…
changed: method DataArray.to_zarr(store: MutableMapping | str | PathLike[str] | None=…, chunk_store: MutableMapping | str | PathLike | None=…, mode: ZarrWriteModes | None=…, synchronizer=…, group: str | None=…, *, encoding: Mapping | None=…, compute: Literal[True]=…, consolidated: bool | None=…, append_dim: Hashable | None=…, region: Mapping[str, slice | Literal['auto']] | Literal['auto'] | None=…, safe_c… → method DataArray.to_zarr(store: ZarrStoreLike | None=…, chunk_store: MutableMapping | str | PathLike | None=…, mode: ZarrWriteModes | None=…, synchronizer=…, group: str | None=…, *, encoding: Mapping | None=…, compute: Literal[True]=…, consolidated: bool | None=…, append_dim: Hashable | None=…, region: Mapping[str, slice | Literal['auto']] | Literal['auto'] | None=…, safe_chunks: bool=…, align_ch…
added: async method DataArray.load_async(**kwargs) -> Self

removed: class DataVariables(Mapping[Any, 'DataArray'])
removed: constructor DataVariables(dataset: Dataset)
removed: function as_dataset(obj: Any) -> Dataset
removed: function merge_data_and_coords(data_vars: DataVars, coords) -> _MergeResult
removed: property DataVariables.dtypes -> Frozen[Hashable, np.dtype]
removed: property DataVariables.variables -> Mapping[Hashable, Variable]
changed: method Dataset.convert_calendar(calendar: CFCalendar, dim: Hashable=…, align_on: Literal['date', 'year', None]=…, missing: Any | None=…, use_cftime: bool | None=…) -> Self → method Dataset.convert_calendar(calendar: CFCalendar, dim: Hashable=…, align_on: Literal['date', 'year'] | None=…, missing: Any | None=…, use_cftime: bool | None=…) -> Self
changed: method Dataset.expand_dims(dim: None | Hashable | Sequence[Hashable] | Mapping[Any, Any]=…, axis: None | int | Sequence[int]=…, create_index_for_new_dim: bool=…, **dim_kwargs: Any) -> Self → method Dataset.expand_dims(dim: Hashable | Sequence[Hashable] | Mapping[Any, Any] | None=…, axis: int | Sequence[int] | None=…, create_index_for_new_dim: bool=…, **dim_kwargs: Any) -> Self
changed: method Dataset.groupby(group: GroupInput=…, *, squeeze: Literal[False]=…, restore_coord_dims: bool=…, eagerly_compute_group: bool=…, **groupers: Grouper) -> DatasetGroupBy → method Dataset.groupby(group: GroupInput=…, *, squeeze: Literal[False]=…, restore_coord_dims: bool=…, eagerly_compute_group: Literal[False] | None=…, **groupers: Grouper) -> DatasetGroupBy
changed: method Dataset.groupby_bins(group: Hashable | DataArray | IndexVariable, bins: Bins, right: bool=…, labels: ArrayLike | None=…, precision: int=…, include_lowest: bool=…, squeeze: Literal[False]=…, restore_coord_dims: bool=…, duplicates: Literal['raise', 'drop']=…, eagerly_compute_group: bool=…) -> DatasetGroupBy → method Dataset.groupby_bins(group: Hashable | DataArray | IndexVariable, bins: Bins, right: bool=…, labels: ArrayLike | None=…, precision: int=…, include_lowest: bool=…, squeeze: Literal[False]=…, restore_coord_dims: bool=…, duplicates: Literal['raise', 'drop']=…, eagerly_compute_group: Literal[False] | None=…) -> DatasetGroupBy
changed: method Dataset.merge(other: CoercibleMapping | DataArray, overwrite_vars: Hashable | Iterable[Hashable]=…, compat: CompatOptions=…, join: JoinOptions=…, fill_value: Any=…, combine_attrs: CombineAttrsOptions=…) -> Self → method Dataset.merge(other: CoercibleMapping | DataArray, overwrite_vars: Hashable | Iterable[Hashable]=…, compat: CompatOptions | CombineKwargDefault=…, join: JoinOptions | CombineKwargDefault=…, fill_value: Any=…, combine_attrs: CombineAttrsOptions=…) -> Self
changed: method Dataset.to_netcdf(path: None=…, mode: NetcdfWriteModes=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Any, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, invalid_netcdf: bool=…, auto_complex: bool | None=…) -> bytes | (path: str | PathLike, mode: NetcdfWriteModes=…, format: T_NetcdfTypes… → method Dataset.to_netcdf(path: None=…, mode: NetcdfWriteModes=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Any, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, invalid_netcdf: bool=…, auto_complex: bool | None=…) -> memoryview | (path: str | PathLike, mode: NetcdfWriteModes=…, format: T_Netcdf…
changed: method Dataset.to_zarr(store: MutableMapping | str | PathLike[str] | None=…, chunk_store: MutableMapping | str | PathLike | None=…, mode: ZarrWriteModes | None=…, synchronizer=…, group: str | None=…, encoding: Mapping | None=…, *, compute: Literal[True]=…, consolidated: bool | None=…, append_dim: Hashable | None=…, region: Mapping[str, slice | Literal['auto']] | Literal['auto'] | None=…, safe_chu… → method Dataset.to_zarr(store: ZarrStoreLike | None=…, chunk_store: MutableMapping | str | PathLike | None=…, mode: ZarrWriteModes | None=…, synchronizer=…, group: str | None=…, encoding: Mapping | None=…, *, compute: Literal[True]=…, consolidated: bool | None=…, append_dim: Hashable | None=…, region: Mapping[str, slice | Literal['auto']] | Literal['auto'] | None=…, safe_chunks: bool=…, align_chun…
changed: method Dataset.update(other: CoercibleMapping) -> Self → method Dataset.update(other: CoercibleMapping) -> None
added: async method Dataset.load_async(**kwargs) -> Self

added: function as_dataset(obj: Any) -> Dataset

added: class DataVariables(Mapping[Hashable, 'DataArray'])
added: constructor DataVariables(dataset: Dataset)
added: property DataVariables.dtypes -> Frozen[Hashable, np.dtype]
added: property DataVariables.variables -> Mapping[Hashable, Variable]

changed: class DataTree(NamedNode['DataTree'], DataTreeAggregations, DataTreeOpsMixin, TreeAttrAccessMixin, Mapping[str, 'DataArray | DataTree']) → class DataTree(NamedNode, DataTreeAggregations, DataTreeOpsMixin, TreeAttrAccessMixin, Mapping[str, 'DataArray | DataTree'])
changed: method DataTree.map_over_datasets(func: Callable, *args: Any) -> DataTree | tuple[DataTree, ...] → method DataTree.map_over_datasets(func: Callable[..., Dataset | None], *args: Any, kwargs: Mapping[str, Any] | None=…) -> DataTree | (func: Callable[..., tuple[Dataset | None, Dataset | None]], *args: Any, kwargs: Mapping[str, Any] | None=…) -> tuple[DataTree, DataTree] | (func: Callable[..., tuple[Dataset | None, ...]], *args: Any, kwargs: Mapping[str, Any] | None=…) -> tuple[DataTree, ...]
changed: method DataTree.pipe(func: Callable | tuple[Callable, str], *args: Any, **kwargs: Any) -> Any → method DataTree.pipe(func: Callable[Concatenate[Self, P], T], *args: P.args, **kwargs: P.kwargs) -> T | (func: tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T
changed: method DataTree.to_netcdf(filepath, mode: NetcdfWriteModes=…, encoding=…, unlimited_dims=…, format: T_DataTreeNetcdfTypes | None=…, engine: T_DataTreeNetcdfEngine | None=…, group: str | None=…, write_inherited_coords: bool=…, compute: bool=…, **kwargs) → method DataTree.to_netcdf(filepath: None=…, mode: NetcdfWriteModes=…, encoding=…, unlimited_dims=…, format: T_DataTreeNetcdfTypes | None=…, engine: T_DataTreeNetcdfEngine | None=…, group: str | None=…, write_inherited_coords: bool=…, compute: bool=…, **kwargs) -> memoryview | (filepath: str | PathLike | io.IOBase, mode: NetcdfWriteModes=…, encoding=…, unlimited_dims=…, format: T_DataTreeNetcdfTyp…
changed: method DataTree.to_zarr(store, mode: ZarrWriteModes=…, encoding=…, consolidated: bool=…, group: str | None=…, write_inherited_coords: bool=…, compute: Literal[True]=…, **kwargs) → method DataTree.to_zarr(store: ZarrStoreLike, mode: ZarrWriteModes=…, encoding=…, consolidated: bool=…, group: str | None=…, write_inherited_coords: bool=…, *, compute: Literal[False], **kwargs) -> Delayed | (store: ZarrStoreLike, mode: ZarrWriteModes=…, encoding=…, consolidated: bool=…, group: str | None=…, write_inherited_coords: bool=…, compute: Literal[True]=…, **kwargs) -> ZarrStore
changed: static method DataTree.from_dict(d: Mapping[str, Dataset | DataTree | None], /, name: str | None=…) -> Self → static method DataTree.from_dict(data: Mapping[str, FromDictDataValue] | None=…, coords: Mapping[str, CoercibleValue] | None=…, *, name: str | None=…, nested: Literal[False]=…) -> Self | (data: Mapping[str, FromDictDataValue | NestedDict[FromDictDataValue]] | None=…, coords: Mapping[str, CoercibleValue | NestedDict[CoercibleValue]] | None=…, *, name: str | None=…, nested: Literal[True]=…) -> Self
added: method DataTree.filter_like(other: DataTree) -> DataTree
added: method DataTree.prune(drop_size_zero_vars: bool=…) -> DataTree
added: variable FromDictDataValue: TypeAlias
added: variable P
added: variable T

removed: variable T_DataTreeNetcdfEngine
removed: variable T_DataTreeNetcdfTypes

removed: function add_note(err: BaseException, msg: str) -> None
changed: function map_over_datasets(func: Callable[..., Dataset | None], *args: Any) -> DataTree | (func: Callable[..., tuple[Dataset | None, Dataset | None]], *args: Any) -> tuple[DataTree, DataTree] | (func: Callable[..., tuple[Dataset | None, ...]], *args: Any) -> tuple[DataTree, ...] → function map_over_datasets(func: Callable[..., Dataset | None], *args: Any, kwargs: Mapping[str, Any] | None=…) -> DataTree | (func: Callable[..., tuple[Dataset | None, Dataset | None]], *args: Any, kwargs: Mapping[str, Any] | None=…) -> tuple[DataTree, DataTree] | (func: Callable[..., tuple[Dataset | None, ...]], *args: Any, kwargs: Mapping[str, Any] | None=…) -> tuple[DataTree, ...]
added: function add_path_context_to_errors(path: str)

removed: variable Row
changed: constructor RenderDataTree(node: DataTree, style=…, childiter: type=…, maxlevel: int | None=…) → constructor RenderDataTree(node: DataTree, style=…, childiter: type=…, maxlevel: int | None=…, maxchildren: int | None=…)
added: class Row(NamedTuple)
added: field Row.fill: str
added: field Row.node: DataTree | str
added: field Row.pre: str

removed: function preprocess_types(t)
changed: function maybe_promote(dtype: np.dtype) -> tuple[np.dtype, Any] → function maybe_promote(dtype: T_dtype) -> tuple[T_dtype, Any]
changed: function result_type(*arrays_and_dtypes: np.typing.ArrayLike | np.typing.DTypeLike, xp=…) -> np.dtype → function result_type(*arrays_and_dtypes: np.typing.ArrayLike | np.typing.DTypeLike | ExtensionDtype, xp=…) -> np.dtype
added: function maybe_promote_to_variable_width(array_or_dtype: np.typing.ArrayLike | np.typing.DTypeLike | ExtensionDtype | str | bytes, *, should_return_str_or_bytes: bool=…) -> np.typing.ArrayLike | np.typing.DTypeLike | ExtensionDtype
added: function should_promote_to_object(arrays_and_dtypes: Iterable[np.typing.ArrayLike | np.typing.DTypeLike | ExtensionDtype], xp) -> bool
added: variable T_dtype

removed: function get_array_namespace(*values)
removed: variable sliding_window_view
changed: function astype(data, dtype, **kwargs) → function astype(data, dtype, *, xp=…, **kwargs)
added: function array_all(array, axis=…, keepdims=…, **kwargs)
added: function array_any(array, axis=…, keepdims=…, **kwargs)
added: function clip(data, min=…, max=…)
added: function cross(*args, **kwargs)
added: function empty_like(a, **kwargs)
added: function full_like(a, fill_value, **kwargs)
added: function gradient(f, *varargs, axis=…, edge_order=…)
added: function isin(element, test_elements, **kwargs)
added: function isna(data: Any) -> bool
added: function logical_not(data)
added: function moveaxis(array, source, destination)
added: function ndim(array) -> int
added: function pad(array, pad_width, **kwargs)
added: function quantile(array, q, axis=…, **kwargs)
added: function sliding_window_view(array, window_shape, axis=…, **kwargs)
added: function tensordot(*args, **kwargs)
added: function transpose(array, axes=…)

removed: constructor PandasExtensionArray(array: T_ExtensionArray)
changed: class PandasExtensionArray(Generic[T_ExtensionArray]) → class PandasExtensionArray(NDArrayMixin, Generic[T_ExtensionArray])
changed: function implements(numpy_function) → function implements(numpy_function_or_name: Callable | str) -> Callable
added: function as_extension_array(array_or_scalar: np.typing.ArrayLike | T_ExtensionArray, dtype: ExtensionDtype | DTypeLikeSave | None, copy: bool=…) -> ExtensionArray
added: function is_scalar(value: object) -> bool
added: function replace_duck_with_extension_array(args) -> tuple
added: function replace_duck_with_series(args) -> tuple
added: function union_unordered_categorical_and_scalar(categorical_dtypes: list[pd.CategoricalDtype], scalars: list[Scalar]) -> pd.CategoricalDtype
added: property PandasExtensionArray.ndim -> int

changed: function inline_index_repr(index: pd.Index, max_width=…) → function inline_index_repr(index: pd.Index, max_width: int) -> str
changed: function summarize_variable(name: Hashable, var: Variable, col_width: int, max_width: int | None=…, is_index: bool=…) → function summarize_variable(name: Hashable, var: Variable, col_width: int | None=…, max_width: int | None=…, is_index: bool=…)

removed: function datatree_node_repr(group_title: str, node: DataTree, show_inherited=…) -> str
changed: function datatree_repr(dt: DataTree) -> str → function datatree_repr(node: DataTree) -> str
added: function datatree_child_repr(node: DataTree, end: bool=…) -> str
added: function datatree_node_sections(node: DataTree, root: bool=…) -> list[str]

changed: field ResolvedGrouper.eagerly_compute_group: bool → field ResolvedGrouper.eagerly_compute_group: Literal[False] | None
changed: method GroupBy.first(skipna: bool | None=…, keep_attrs: bool | None=…) → method GroupBy.first(skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
changed: method GroupBy.last(skipna: bool | None=…, keep_attrs: bool | None=…) → method GroupBy.last(skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray

changed: constructor Indexes(indexes: Mapping[Any, T_PandasOrXarrayIndex] | None=…, variables: Mapping[Any, Variable] | None=…, index_type: type[Index] | type[pd.Index]=…) → constructor Indexes(indexes: Mapping[Any, T_PandasOrXarrayIndex] | None=…, variables: Mapping[Any, Variable] | None=…, index_type: type[Index | pd.Index]=…)
changed: field PandasMultiIndex.level_coords_dtype: dict[str, Any] → field PandasMultiIndex.level_coords_dtype: dict[Hashable | None, Any]
changed: function indexes_all_equal(elements: Sequence[tuple[Index, dict[Hashable, Variable]]]) -> bool → function indexes_all_equal(elements: Sequence[tuple[Index, dict[Hashable, Variable]]], exclude_dims: frozenset[Hashable]) -> bool
changed: method Index.equals(other: Self) -> bool → method Index.equals(other: Index) -> bool | (other: Index, *, exclude: frozenset[Hashable] | None=…) -> bool
changed: method Index.isel(indexers: Mapping[Any, int | slice | np.ndarray | Variable]) -> Self | None → method Index.isel(indexers: Mapping[Any, int | slice | np.ndarray | Variable]) -> Index | None
changed: method PandasIndex.equals(other: Index) → method PandasIndex.equals(other: Index, *, exclude: frozenset[Hashable] | None=…)
added: class CoordinateTransformIndex(Index)
added: constructor CoordinateTransformIndex(transform: CoordinateTransform)
added: field CoordinateTransformIndex.transform: CoordinateTransform
added: method CoordinateTransformIndex.create_variables(variables: Mapping[Any, Variable] | None=…) -> IndexVars
added: method CoordinateTransformIndex.equals(other: Index, *, exclude: frozenset[Hashable] | None=…) -> bool
added: method CoordinateTransformIndex.isel(indexers: Mapping[Any, int | slice | np.ndarray | Variable]) -> Index | None
added: method CoordinateTransformIndex.rename(name_dict: Mapping[Any, Hashable], dims_dict: Mapping[Any, Hashable]) -> Self
added: method CoordinateTransformIndex.sel(labels: dict[Any, Any], method=…, tolerance=…) -> IndexSelResult
added: method Index.should_add_coord_to_array(name: Hashable, var: Variable, dims: set[Hashable]) -> bool

removed: property PandasIndexingAdapter.dtype -> np.dtype
changed: class ArrayApiIndexingAdapter(ExplicitlyIndexedNDArrayMixin) → class ArrayApiIndexingAdapter(IndexingAdapter)
changed: class DaskIndexingAdapter(ExplicitlyIndexedNDArrayMixin) → class DaskIndexingAdapter(IndexingAdapter)
changed: class NumpyIndexingAdapter(ExplicitlyIndexedNDArrayMixin) → class NumpyIndexingAdapter(IndexingAdapter)
changed: class PandasIndexingAdapter(ExplicitlyIndexedNDArrayMixin) → class PandasIndexingAdapter(IndexingAdapter)
changed: constructor BasicIndexer(key: tuple[int | np.integer | slice, ...]) → constructor BasicIndexer(key: tuple[BasicIndexerType, ...])
changed: constructor OuterIndexer(key: tuple[int | np.integer | slice | np.ndarray[Any, np.dtype[np.generic]], ...]) → constructor OuterIndexer(key: tuple[BasicIndexerType | np.ndarray[Any, np.dtype[np.generic]], ...])
changed: constructor PandasIndexingAdapter(array: pd.Index, dtype: DTypeLike=…) → constructor PandasIndexingAdapter(array: pd.Index, dtype: DTypeLike | pd.api.extensions.ExtensionDtype | None=…)
changed: constructor PandasMultiIndexingAdapter(array: pd.MultiIndex, dtype: DTypeLike=…, level: str | None=…) → constructor PandasMultiIndexingAdapter(array: pd.MultiIndex, dtype: DTypeLike | pd.api.extensions.ExtensionDtype | None=…, level: str | None=…)
changed: method PandasIndexingAdapter.get_duck_array() -> np.ndarray → method PandasIndexingAdapter.get_duck_array() -> np.ndarray | PandasExtensionArray
added: async function async_explicit_indexing_adapter(key: ExplicitIndexer, shape: _Shape, indexing_support: IndexingSupport, raw_indexing_method: Callable[..., Any]) -> Any
added: async method CopyOnWriteArray.async_get_duck_array()
added: async method ExplicitlyIndexedNDArrayMixin.async_get_duck_array()
added: async method IndexingAdapter.async_get_duck_array()
added: async method LazilyIndexedArray.async_get_duck_array()
added: async method LazilyVectorizedIndexedArray.async_get_duck_array()
added: async method MemoryCachedArray.async_get_duck_array()
added: class CoordinateTransformIndexingAdapter(IndexingAdapter)
added: class IndexingAdapter(ExplicitlyIndexedNDArrayMixin)
added: constructor CoordinateTransformIndexingAdapter(transform: CoordinateTransform, coord_name: Hashable, dims: tuple[str, ...] | None=…)
added: function normalize_array(array: np.ndarray[Any, np.dtype[np.integer]], size: int) -> np.ndarray[Any, np.dtype[np.integer]]
added: function normalize_indexer(indexer, size)
added: function normalize_slice(sl: slice, size: int) -> slice
added: function slice_slice_by_array(old_slice: slice, array: np.ndarray[Any, np.dtype[np.integer]], size: int) -> np.ndarray[Any, np.dtype[np.integer]]
added: method CoordinateTransformIndexingAdapter.get_duck_array() -> np.ndarray
added: method CoordinateTransformIndexingAdapter.transpose(order: Iterable[int]) -> Self
added: method IndexingAdapter.get_duck_array()
added: property CoordinateTransformIndexingAdapter.dtype -> np.dtype
added: property CoordinateTransformIndexingAdapter.shape -> tuple[int, ...]
added: property PandasIndexingAdapter.dtype -> np.dtype | pd.api.extensions.ExtensionDtype
added: property PandasIndexingAdapter.nbytes -> int
added: variable BasicIndexerType
added: variable OuterIndexerType

removed: class Context
removed: class MergeError(ValueError)
removed: constructor Context(func)
removed: function broadcast_dimension_size(variables: list[Variable]) -> dict[Hashable, int]
removed: function coerce_pandas_values(objects: Iterable[CoercibleMapping]) -> list[DatasetLike]
removed: function collect_from_coordinates(list_of_coords: list[Coordinates]) -> dict[Hashable, list[MergeElement]]
removed: function collect_variables_and_indexes(list_of_mappings: Iterable[DatasetLike], indexes: Mapping[Any, Any] | None=…) -> dict[Hashable, list[MergeElement]]
removed: function dataset_merge_method(dataset: Dataset, other: CoercibleMapping, overwrite_vars: Hashable | Iterable[Hashable], compat: CompatOptions, join: JoinOptions, fill_value: Any, combine_attrs: CombineAttrsOptions) -> _MergeResult
removed: function dataset_update_method(dataset: Dataset, other: CoercibleMapping) -> _MergeResult
removed: function determine_coords(list_of_mappings: Iterable[DatasetLike]) -> tuple[set[Hashable], set[Hashable]]
removed: function merge(objects: Iterable[DataArray | CoercibleMapping], compat: CompatOptions=…, join: JoinOptions=…, fill_value: object=…, combine_attrs: CombineAttrsOptions=…) -> Dataset
removed: function merge_attrs(variable_attrs, combine_attrs, context=…)
removed: function merge_collected(grouped: dict[Any, list[MergeElement]], prioritized: Mapping[Any, MergeElement] | None=…, compat: CompatOptions=…, combine_attrs: CombineAttrsOptions=…, equals: dict[Any, bool] | None=…) -> tuple[dict[Hashable, Variable], dict[Hashable, Index]]
removed: function merge_coordinates_without_align(objects: list[Coordinates], prioritized: Mapping[Any, MergeElement] | None=…, exclude_dims: Set=…, combine_attrs: CombineAttrsOptions=…) -> tuple[dict[Hashable, Variable], dict[Hashable, Index]]
removed: function merge_coords(objects: Iterable[CoercibleMapping], compat: CompatOptions=…, join: JoinOptions=…, priority_arg: int | None=…, indexes: Mapping[Any, Index] | None=…, fill_value: object=…) -> tuple[dict[Hashable, Variable], dict[Hashable, Index]]
removed: function merge_core(objects: Iterable[CoercibleMapping], compat: CompatOptions=…, join: JoinOptions=…, combine_attrs: CombineAttrsOptions=…, priority_arg: int | None=…, explicit_coords: Iterable[Hashable] | None=…, indexes: Mapping[Any, Any] | None=…, fill_value: object=…, skip_align_args: list[int] | None=…) -> _MergeResult
removed: function unique_variable(name: Hashable, variables: list[Variable], compat: CompatOptions=…, equals: bool | None=…) -> Variable
removed: variable ArrayLike
removed: variable CoercibleMapping
removed: variable CoercibleValue
removed: variable DatasetLike
removed: variable DimsLike
removed: variable MergeElement
removed: variable PANDAS_TYPES
removed: variable VariableLike
removed: variable XarrayValue

removed: function interp_func(var, x, new_x, method: InterpOptions, kwargs)
changed: function decompose_interp(indexes_coords) → function decompose_interp(indexes_coords: SourceDest) -> Generator[SourceDest, None]
changed: function interp(var, indexes_coords, method: InterpOptions, **kwargs) → function interp(var: Variable, indexes_coords: SourceDest, method: InterpOptions, **kwargs) -> Variable
added: function interpolate_variable(var: Variable, indexes_coords: SourceDest, *, method: InterpOptions, kwargs: dict[str, Any]) -> Variable
added: variable InterpCallable
added: variable Interpolator
added: variable SourceDest
added: variable T

removed: function nanargmax(a, axis=…)
removed: function nanargmin(a, axis=…)
removed: function nancumprod(a, axis=…, dtype=…, out=…)
removed: function nancumsum(a, axis=…, dtype=…, out=…)
removed: function nanmax(a, axis=…, out=…)
removed: function nanmean(a, axis=…, dtype=…, out=…)
removed: function nanmedian(a, axis=…, out=…)
removed: function nanmin(a, axis=…, out=…)
removed: function nanprod(a, axis=…, dtype=…, out=…, min_count=…)
removed: function nanstd(a, axis=…, dtype=…, out=…, ddof=…)
removed: function nansum(a, axis=…, dtype=…, out=…, min_count=…)
removed: function nanvar(a, axis=…, dtype=…, out=…, ddof=…)

removed: function isdtype(dtype: np.dtype[Any] | type[Any], kind: DTypeLike | tuple[DTypeLike, ...]) -> bool
removed: variable HAS_STRING_DTYPE
removed: variable kind_mapping

removed: class IncludeNumpySameMethods
removed: class IncludeReduceMethods
removed: function fillna(data, other, join=…, dataset_join=…)
removed: function get_op(name)
removed: function inject_numpy_same(cls)
removed: function inject_reduce_methods(cls)
removed: function inplace_to_noninplace_op(f)
removed: function op_str(name)
removed: function where_method(self, cond, other=…)
removed: variable NAN_REDUCE_METHODS
removed: variable NON_INPLACE_OP
removed: variable NUMPY_SAME_METHODS
removed: variable NUM_BINARY_OPS
removed: variable REDUCE_METHODS
removed: variable argsort
removed: variable bn
removed: variable conj
removed: variable conjugate
removed: variable has_bottleneck
removed: variable round_

changed: field T_Options.display_default_indexes: Literal['default', True, False] → field T_Options.display_default_indexes: Literal['default'] | bool
changed: field T_Options.display_expand_attrs: Literal['default', True, False] → field T_Options.display_expand_attrs: Literal['default'] | bool
changed: field T_Options.display_expand_coords: Literal['default', True, False] → field T_Options.display_expand_coords: Literal['default'] | bool
changed: field T_Options.display_expand_data: Literal['default', True, False] → field T_Options.display_expand_data: Literal['default'] | bool
changed: field T_Options.display_expand_data_vars: Literal['default', True, False] → field T_Options.display_expand_data_vars: Literal['default'] | bool
changed: field T_Options.display_expand_groups: Literal['default', True, False] → field T_Options.display_expand_groups: Literal['default'] | bool
changed: field T_Options.display_expand_indexes: Literal['default', True, False] → field T_Options.display_expand_indexes: Literal['default'] | bool
changed: field T_Options.keep_attrs: Literal['default', True, False] → field T_Options.keep_attrs: Literal['default'] | bool
added: field T_Options.display_max_children: int
added: field T_Options.netcdf_engine_order: Sequence[Literal['netcdf4', 'h5netcdf', 'scipy']]
added: field T_Options.use_new_combine_kwarg_defaults: bool

removed: function count_not_none(*args) -> int
removed: function nanosecond_precision_timestamp(*args, **kwargs) -> pd.Timestamp
removed: variable NoDefault
removed: variable no_default

removed: class Coarsen(CoarsenArithmetic, Generic[T_Xarray])
removed: class DataArrayCoarsen(Coarsen['DataArray'])
removed: class DataArrayRolling(Rolling['DataArray'])
removed: class DatasetCoarsen(Coarsen['Dataset'])
removed: class DatasetRolling(Rolling['Dataset'])
removed: class Rolling(Generic[T_Xarray])
removed: constructor Coarsen(obj: T_Xarray, windows: Mapping[Any, int], boundary: CoarsenBoundaryOptions, side: SideOptions | Mapping[Any, SideOptions], coord_func: str | Callable | Mapping[Any, str | Callable]) -> None
removed: constructor DataArrayRolling(obj: DataArray, windows: Mapping[Any, int], min_periods: int | None=…, center: bool | Mapping[Any, bool]=…) -> None
removed: constructor DatasetRolling(obj: Dataset, windows: Mapping[Any, int], min_periods: int | None=…, center: bool | Mapping[Any, bool]=…) -> None
removed: constructor Rolling(obj: T_Xarray, windows: Mapping[Any, int], min_periods: int | None=…, center: bool | Mapping[Any, bool]=…) -> None
removed: field Coarsen.boundary: CoarsenBoundaryOptions
removed: field Coarsen.coord_func: Mapping[Hashable, str | Callable]
removed: field Coarsen.obj: T_Xarray
removed: field Coarsen.side: SideOptions | Mapping[Hashable, SideOptions]
removed: field Coarsen.windows: Mapping[Hashable, int]
removed: field Rolling.argmax
removed: field Rolling.argmin
removed: field Rolling.center: list[bool]
removed: field Rolling.dim: list[Hashable]
removed: field Rolling.max
removed: field Rolling.mean
removed: field Rolling.median
removed: field Rolling.min
removed: field Rolling.min_periods: int
removed: field Rolling.obj: T_Xarray
removed: field Rolling.prod
removed: field Rolling.std
removed: field Rolling.sum
removed: field Rolling.var
removed: field Rolling.window: list[int]
removed: method Coarsen.construct(window_dim=…, keep_attrs=…, **window_dim_kwargs) -> T_Xarray
removed: method DataArrayCoarsen.reduce(func: Callable, keep_attrs: bool | None=…, **kwargs) -> DataArray
removed: method DataArrayRolling.construct(window_dim: Hashable | Mapping[Any, Hashable] | None=…, *, stride: int | Mapping[Any, int]=…, fill_value: Any=…, keep_attrs: bool | None=…, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **window_dim_kwargs: Hashable) -> DataArray
removed: method DataArrayRolling.reduce(func: Callable, keep_attrs: bool | None=…, *, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **kwargs: Any) -> DataArray
removed: method DatasetCoarsen.reduce(func: Callable, keep_attrs=…, **kwargs) -> Dataset
removed: method DatasetRolling.construct(window_dim: Hashable | Mapping[Any, Hashable] | None=…, *, stride: int | Mapping[Any, int]=…, fill_value: Any=…, keep_attrs: bool | None=…, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **window_dim_kwargs: Hashable) -> Dataset
removed: method DatasetRolling.reduce(func: Callable, keep_attrs: bool | None=…, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **kwargs: Any) -> DataArray
removed: method Rolling.count(keep_attrs: bool | None=…) -> T_Xarray
removed: property Rolling.ndim -> int
removed: variable RollingKey
removed: variable bottleneck

removed: class RollingExp(Generic[T_DataWithCoords])
removed: constructor RollingExp(obj: T_DataWithCoords, windows: Mapping[Any, int | float], window_type: str=…, min_weight: float=…)
removed: method RollingExp.corr(other: T_DataWithCoords) -> T_DataWithCoords
removed: method RollingExp.cov(other: T_DataWithCoords) -> T_DataWithCoords
removed: method RollingExp.mean(keep_attrs: bool | None=…) -> T_DataWithCoords
removed: method RollingExp.std() -> T_DataWithCoords
removed: method RollingExp.sum(keep_attrs: bool | None=…) -> T_DataWithCoords
removed: method RollingExp.var() -> T_DataWithCoords

removed: property TreeNode.ancestors -> tuple[Tree, ...]
removed: property TreeNode.children -> Mapping[str, Tree]
removed: property TreeNode.descendants -> tuple[Tree, ...]
removed: property TreeNode.leaves -> tuple[Tree, ...]
removed: property TreeNode.lineage -> tuple[Tree, ...]
removed: property TreeNode.parent -> Tree | None
removed: property TreeNode.parents -> tuple[Tree, ...]
removed: property TreeNode.root -> Tree
removed: property TreeNode.siblings -> dict[str, Tree]
removed: property TreeNode.subtree -> Iterator[Tree]
removed: property TreeNode.subtree_with_keys -> Iterator[tuple[str, Tree]]
removed: variable Tree
changed: class NamedNode(TreeNode, Generic[Tree]) → class NamedNode(TreeNode)
changed: class TreeNode(Generic[Tree]) → class TreeNode
changed: constructor NamedNode(name=…, children=…) → constructor NamedNode(name: str | None=…, children: Mapping[str, Self] | None=…)
changed: constructor TreeNode(children: Mapping[str, Tree] | None=…) → constructor TreeNode(children: Mapping[str, Self] | None=…)
changed: method NamedNode.find_common_ancestor(other: NamedNode) -> NamedNode → method NamedNode.find_common_ancestor(other: Self) -> Self
changed: method NamedNode.relative_to(other: NamedNode) -> str → method NamedNode.relative_to(other: Self) -> str
changed: method TreeNode.get(key: str, default: Tree | None=…) -> Tree | None → method TreeNode.get(key: str, default: Self | None=…) -> Self | None
changed: method TreeNode.iter_lineage() -> tuple[Tree, ...] → method TreeNode.iter_lineage() -> tuple[Self, ...]
changed: method TreeNode.same_tree(other: Tree) -> bool → method TreeNode.same_tree(other: Self) -> bool
added: method NodePath.absolute() -> Self
added: property TreeNode.ancestors -> tuple[Self, ...]
added: property TreeNode.children -> Mapping[str, Self]
added: property TreeNode.descendants -> tuple[Self, ...]
added: property TreeNode.leaves -> tuple[Self, ...]
added: property TreeNode.lineage -> tuple[Self, ...]
added: property TreeNode.parent -> Self | None
added: property TreeNode.parents -> tuple[Self, ...]
added: property TreeNode.root -> Self
added: property TreeNode.siblings -> dict[str, Self]
added: property TreeNode.subtree -> Iterator[Self]
added: property TreeNode.subtree_with_keys -> Iterator[tuple[str, Self]]

removed: variable Self: Any
changed: method BaseBuffer.seek(__offset: int, __whence: int=…) -> int → method BaseBuffer.seek(offset: int, whence: int=…, /) -> int
changed: method ReadBuffer.read(__n: int=…) -> AnyStr_co → method ReadBuffer.read(n: int=…, /) -> AnyStr_co
added: class Closable(Protocol)
added: class Lock(Protocol)
added: method Closable.close() -> None
added: method Lock.acquire(*args, **kwargs) -> Any
added: method Lock.release() -> None
added: variable NestedDict
added: variable PDDatetimeUnitOptions
added: variable T_Aligner
added: variable ZarrGroup
added: variable ZarrStoreLike

changed: function parse_dims_as_set(dim: Dims, all_dims: set[Hashable], *, check_exists: bool=…, replace_none: Literal[True]=…) -> set[Hashable] | (dim: Dims, all_dims: set[Hashable], *, check_exists: bool=…, replace_none: Literal[False]) -> set[Hashable] | None | EllipsisType → function parse_dims_as_set(dim: Dims, all_dims: set[Hashable], *, check_exists: bool=…, replace_none: Literal[True]=…) -> set[Hashable] | (dim: Dims, all_dims: set[Hashable], *, check_exists: bool=…, replace_none: Literal[False]) -> set[Hashable] | EllipsisType | None
changed: function parse_dims_as_tuple(dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[True]=…) -> tuple[Hashable, ...] | (dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[False]) -> tuple[Hashable, ...] | None | EllipsisType → function parse_dims_as_tuple(dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[True]=…) -> tuple[Hashable, ...] | (dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[False]) -> tuple[Hashable, ...] | EllipsisType | None
changed: function parse_ordered_dims(dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[True]=…) -> tuple[Hashable, ...] | (dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[False]) -> tuple[Hashable, ...] | None | EllipsisType → function parse_ordered_dims(dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[True]=…) -> tuple[Hashable, ...] | (dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[False]) -> tuple[Hashable, ...] | EllipsisType | None
added: function did_you_mean(word: Hashable, possibilities: Iterable[Hashable], *, n: int=…) -> str
added: function flat_items(nested: Mapping[str, NestedDict[T] | T], prefix: str | None=…, separator: str=…) -> Iterable[tuple[str, T]]
added: function is_allowed_extension_array(array: Any) -> bool
added: function is_allowed_extension_array_dtype(dtype: Any)
added: function strip_uri_params(uri: str) -> str

removed: property IndexVariable.level_names -> list[str] | None
removed: variable NON_NANOSECOND_WARNING
changed: method Variable.compute(**kwargs) → method Variable.compute(**kwargs) -> Self
changed: method Variable.load(**kwargs) → method Variable.load(**kwargs) -> Self
added: async method IndexVariable.load_async()
added: async method Variable.load_async(**kwargs) -> Self
added: property IndexVariable.level_names -> list[Hashable | None] | None
added: variable UNSUPPORTED_EXTENSION_ARRAY_TYPES

removed: class DataArrayWeighted(Weighted['DataArray'])
removed: class DatasetWeighted(Weighted['Dataset'])
removed: class Weighted(Generic[T_Xarray])
removed: constructor Weighted(obj: T_Xarray, weights: T_DataArray) -> None
removed: method Weighted.mean(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
removed: method Weighted.quantile(q: ArrayLike, *, dim: Dims=…, keep_attrs: bool | None=…, skipna: bool=…) -> T_Xarray
removed: method Weighted.std(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
removed: method Weighted.sum(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
removed: method Weighted.sum_of_squares(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
removed: method Weighted.sum_of_weights(dim: Dims=…, *, keep_attrs: bool | None=…) -> T_Xarray
removed: method Weighted.var(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
removed: variable QUANTILE_METHODS

added: class SeasonGrouper(Grouper)
added: class SeasonResampler(Resampler)
added: field SeasonGrouper.seasons: Sequence[str]
added: field SeasonResampler.drop_incomplete: bool
added: field SeasonResampler.season_inds: Sequence[Sequence[int]]
added: field SeasonResampler.season_tuples: Mapping[str, Sequence[int]]
added: field SeasonResampler.seasons: Sequence[str]
added: method Resampler.compute_chunks(variable: Variable, *, dim: Hashable) -> tuple[int, ...]
added: method SeasonGrouper.factorize(group: T_Group) -> EncodedGroups
added: method SeasonGrouper.reset() -> Self
added: method SeasonResampler.compute_chunks(variable: Variable, *, dim: Hashable) -> tuple[int, ...]
added: method SeasonResampler.factorize(group: T_Group) -> EncodedGroups
added: method SeasonResampler.reset() -> Self
added: method TimeResampler.compute_chunks(variable: Variable, *, dim: Hashable) -> tuple[int, ...]

added: export CoordinateTransform
added: export CoordinateTransformIndex
added: export NDPointIndex
added: export RangeIndex
added: export TreeAdapter

added: class NDPointIndex(Index, Generic[T_TreeAdapter])
added: class ScipyKDTreeAdapter(TreeAdapter)
added: class TreeAdapter(abc.ABC)
added: constructor NDPointIndex(tree_obj: T_TreeAdapter, *, coord_names: tuple[Hashable, ...], dims: tuple[Hashable, ...], shape: tuple[int, ...])
added: constructor ScipyKDTreeAdapter(points: np.ndarray, options: Mapping[str, Any])
added: constructor TreeAdapter(points: np.ndarray, *, options: Mapping[str, Any])
added: function get_points(coords: Iterable[Variable | Any]) -> np.ndarray
added: method NDPointIndex.create_variables(variables: Mapping[Any, Variable] | None=…) -> dict[Any, Variable]
added: method NDPointIndex.equals(other: Index, *, exclude: frozenset[Hashable] | None=…) -> bool
added: method NDPointIndex.rename(name_dict: Mapping[Any, Hashable], dims_dict: Mapping[Any, Hashable]) -> Self
added: method NDPointIndex.sel(labels: dict[Any, Any], method=…, tolerance=…) -> IndexSelResult
added: method ScipyKDTreeAdapter.equals(other: Self) -> bool
added: method ScipyKDTreeAdapter.query(points: np.ndarray) -> tuple[np.ndarray, np.ndarray]
added: method TreeAdapter.equals(other: Self) -> bool
added: method TreeAdapter.query(points: np.ndarray) -> tuple[np.ndarray, np.ndarray]
added: static method NDPointIndex.from_variables(variables: Mapping[Any, Variable], *, options: Mapping[str, Any]) -> Self
added: variable T_TreeAdapter

added: class RangeCoordinateTransform(CoordinateTransform)
added: class RangeIndex(CoordinateTransformIndex)
added: constructor RangeCoordinateTransform(start: float, stop: float, size: int, coord_name: Hashable, dim: str, dtype: Any=…)
added: constructor RangeIndex(transform: RangeCoordinateTransform)
added: field RangeCoordinateTransform.start: float
added: field RangeCoordinateTransform.stop: float
added: field RangeIndex.transform: RangeCoordinateTransform
added: method RangeCoordinateTransform.equals(other: CoordinateTransform, exclude: frozenset[Hashable] | None=…) -> bool
added: method RangeCoordinateTransform.forward(dim_positions: dict[str, Any]) -> dict[Hashable, Any]
added: method RangeCoordinateTransform.reverse(coord_labels: dict[Hashable, Any]) -> dict[str, Any]
added: method RangeCoordinateTransform.slice(sl: slice) -> RangeCoordinateTransform
added: method RangeIndex.isel(indexers: Mapping[Any, int | slice | np.ndarray | Variable]) -> Index | None
added: method RangeIndex.sel(labels: dict[Any, Any], method=…, tolerance=…) -> IndexSelResult
added: method RangeIndex.to_pandas_index() -> pd.Index
added: property RangeCoordinateTransform.coord_name -> Hashable
added: property RangeCoordinateTransform.dim -> str
added: property RangeCoordinateTransform.size -> int
added: property RangeCoordinateTransform.step -> float
added: property RangeIndex.coord_name -> Hashable
added: property RangeIndex.dim -> str
added: property RangeIndex.size -> int
added: property RangeIndex.start -> float
added: property RangeIndex.step -> float
added: property RangeIndex.stop -> float
added: static method RangeIndex.arange(start: float | None=…, stop: float | None=…, step: float | None=…, *, coord_name: Hashable | None=…, dim: str, dtype: Any=…) -> RangeIndex
added: static method RangeIndex.from_variables(variables: Mapping[Any, Variable], *, options: Mapping[str, Any]) -> RangeIndex
added: static method RangeIndex.linspace(start: float, stop: float, num: int=…, endpoint: bool=…, *, coord_name: Hashable | None=…, dim: str, dtype: Any=…) -> RangeIndex

changed: method NamedArray.get_axis_num(dim: Iterable[Hashable]) -> tuple[int, ...] | (dim: Hashable) -> int → method NamedArray.get_axis_num(dim: str) -> int | (dim: Iterable[Hashable]) -> tuple[int, ...] | (dim: Hashable) -> int

added: method DaskManager.get_auto_chunk_size() -> int

changed: function result_type(*arrays_and_dtypes: np.typing.ArrayLike | np.typing.DTypeLike) -> np.dtype[np.generic] → function result_type(*arrays_and_dtypes: np.typing.ArrayLike | np.typing.DTypeLike | None) -> np.dtype[np.generic]

added: method ChunkManagerEntrypoint.get_auto_chunk_size() -> int
added: variable KNOWN_CHUNKMANAGERS

added: async function async_to_duck_array(data: Any, **kwargs: dict[str, Any]) -> duckarray[_ShapeType, _DType]

added: function fake_target_chunksize(data: DuckArray[Any], limit: int) -> tuple[int, np.dtype[Any]]

changed: method FacetGrid.set_xlabels(label: None | str=…, **kwargs: Any) -> None → method FacetGrid.set_xlabels(label: str | None=…, **kwargs: Any) -> None
changed: method FacetGrid.set_ylabels(label: None | str=…, **kwargs: Any) -> None → method FacetGrid.set_ylabels(label: str | None=…, **kwargs: Any) -> None
changed: method FacetGrid.set_zlabels(label: None | str=…, **kwargs: Any) -> None → method FacetGrid.set_zlabels(label: str | None=…, **kwargs: Any) -> None

added: class Aligner(Generic[T_Alignable])
added: class AlignmentError(ValueError)
added: constructor Aligner(objects: Iterable[T_Alignable], join: JoinOptions | CombineKwargDefault=…, indexes: Mapping[Any, Any] | None=…, exclude_dims: str | Iterable[Hashable]=…, exclude_vars: Iterable[Hashable]=…, method: str | None=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value: Any=…, sparse: bool=…)
added: field Aligner.aligned_index_vars: dict[MatchingIndexKey, dict[Hashable, Variable]]
added: field Aligner.aligned_indexes: dict[MatchingIndexKey, Index]
added: field Aligner.all_index_vars: dict[MatchingIndexKey, list[dict[Hashable, Variable]]]
added: field Aligner.all_indexes: dict[MatchingIndexKey, list[Index]]
added: field Aligner.copy: bool
added: field Aligner.exclude_dims: frozenset[Hashable]
added: field Aligner.exclude_vars: frozenset[Hashable]
added: field Aligner.fill_value: Any
added: field Aligner.index_vars: dict[MatchingIndexKey, dict[Hashable, Variable]]
added: field Aligner.indexes: dict[MatchingIndexKey, Index]
added: field Aligner.join: JoinOptions | CombineKwargDefault
added: field Aligner.keep_original_indexes: set[MatchingIndexKey]
added: field Aligner.new_indexes: Indexes[Index]
added: field Aligner.objects: tuple[T_Alignable, ...]
added: field Aligner.objects_matching_index_vars: tuple[dict[MatchingIndexKey, dict[Hashable, Variable]], ...]
added: field Aligner.reindex: dict[MatchingIndexKey, bool]
added: field Aligner.reindex_kwargs: dict[str, Any]
added: field Aligner.results: tuple[T_Alignable, ...]
added: field Aligner.sparse: bool
added: field Aligner.unindexed_dim_sizes: dict[Hashable, set]
added: function align(obj1: T_Obj1, /, *, join: JoinOptions | CombineKwargDefault=…, copy: bool=…, indexes=…, exclude: str | Iterable[Hashable]=…, fill_value=…) -> tuple[T_Obj1] | (obj1: T_Obj1, obj2: T_Obj2, /, *, join: JoinOptions | CombineKwargDefault=…, copy: bool=…, indexes=…, exclude: str | Iterable[Hashable]=…, fill_value=…) -> tuple[T_Obj1, T_Obj2] | (obj1: T_Obj1, obj2: T_Obj2, obj3: T_Obj3, /,…
added: function broadcast(obj1: T_Obj1, /, *, exclude: str | Iterable[Hashable] | None=…) -> tuple[T_Obj1] | (obj1: T_Obj1, obj2: T_Obj2, /, *, exclude: str | Iterable[Hashable] | None=…) -> tuple[T_Obj1, T_Obj2] | (obj1: T_Obj1, obj2: T_Obj2, obj3: T_Obj3, /, *, exclude: str | Iterable[Hashable] | None=…) -> tuple[T_Obj1, T_Obj2, T_Obj3] | (obj1: T_Obj1, obj2: T_Obj2, obj3: T_Obj3, obj4: T_Obj4, /, *,…
added: function deep_align(objects: Iterable[Any], join: JoinOptions | CombineKwargDefault=…, copy: bool=…, indexes=…, exclude: str | Iterable[Hashable]=…, raise_on_invalid: bool=…, fill_value=…) -> list[Any]
added: function reindex(obj: T_Alignable, indexers: Mapping[Any, Any], method: str | None=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value: Any=…, sparse: bool=…, exclude_vars: Iterable[Hashable]=…) -> T_Alignable
added: function reindex_like(obj: T_Alignable, other: Dataset | DataArray, method: str | None=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value: Any=…) -> T_Alignable
added: function reindex_variables(variables: Mapping[Any, Variable], dim_pos_indexers: Mapping[Any, Any], copy: bool=…, fill_value: Any=…, sparse: bool=…) -> dict[Hashable, Variable]
added: method Aligner.align() -> None
added: method Aligner.align_indexes() -> None
added: method Aligner.assert_unindexed_dim_sizes_equal() -> None
added: method Aligner.find_matching_indexes() -> None
added: method Aligner.find_matching_unindexed_dims() -> None
added: method Aligner.override_indexes() -> None
added: method Aligner.reindex_all() -> None
added: variable CoordNamesAndDims
added: variable IndexVarsToAlign
added: variable IndexesToAlign
added: variable MatchingIndexKey
added: variable T_Obj1
added: variable T_Obj2
added: variable T_Obj3
added: variable T_Obj4
added: variable T_Obj5

added: function unify_chunks(obj: _T, /) -> tuple[_T] | (obj1: _T, obj2: _U, /) -> tuple[_T, _U] | (obj1: _T, obj2: _U, obj3: _V, /) -> tuple[_T, _U, _V] | (*objects: Dataset | DataArray) -> tuple[Dataset | DataArray, ...]
added: variable MissingCoreDimOptions

added: function combine_by_coords(data_objects: Iterable[Dataset | DataArray]=…, compat: CompatOptions | CombineKwargDefault=…, data_vars: Literal['all', 'minimal', 'different'] | None | list[str] | CombineKwargDefault=…, coords: str | CombineKwargDefault=…, fill_value: object=…, join: JoinOptions | CombineKwargDefault=…, combine_attrs: CombineAttrsOptions=…) -> Dataset | DataArray
added: function combine_nested(datasets: DatasetHyperCube, concat_dim: str | DataArray | list[str] | Sequence[str | DataArray | pd.Index | None] | None, compat: str | CombineKwargDefault=…, data_vars: str | CombineKwargDefault=…, coords: str | CombineKwargDefault=…, fill_value: object=…, join: JoinOptions | CombineKwargDefault=…, combine_attrs: CombineAttrsOptions=…) -> Dataset | (datasets: DataTreeHype…
added: function groupby_defaultdict(iter: list[T], key: Callable[[T], K]) -> Iterator[tuple[K, Iterator[T]]]
added: function vars_as_keys(ds)
added: variable DataTreeHyperCube: TypeAlias
added: variable DatasetHyperCube: TypeAlias
added: variable DatasetLike: TypeAlias
added: variable K
added: variable T

added: function concat(objs: Iterable[DataTree], dim: Hashable | T_Variable | T_DataArray | pd.Index | Any, data_vars: T_DataVars | CombineKwargDefault=…, coords: ConcatOptions | Iterable[Hashable] | CombineKwargDefault=…, compat: CompatOptions | CombineKwargDefault=…, positions: Iterable[Iterable[int]] | None=…, fill_value: object=…, join: JoinOptions | CombineKwargDefault=…, combine_attrs: CombineAttr…
added: variable T_DataVars

added: class Context
added: class MergeError(ValueError)
added: constructor Context(func)
added: function broadcast_dimension_size(variables: list[Variable]) -> dict[Hashable, int]
added: function coerce_pandas_values(objects: Iterable[CoercibleMapping]) -> list[DatasetLike]
added: function collect_from_coordinates(list_of_coords: list[Coordinates]) -> dict[Hashable, list[MergeElement]]
added: function collect_variables_and_indexes(list_of_mappings: Iterable[DatasetLike], indexes: Mapping[Any, Any] | None=…) -> dict[Hashable, list[MergeElement]]
added: function dataset_merge_method(dataset: Dataset, other: CoercibleMapping, overwrite_vars: Hashable | Iterable[Hashable], compat: CompatOptions | CombineKwargDefault, join: JoinOptions | CombineKwargDefault, fill_value: Any, combine_attrs: CombineAttrsOptions) -> _MergeResult
added: function dataset_update_method(dataset: Dataset, other: CoercibleMapping) -> _MergeResult
added: function determine_coords(list_of_mappings: Iterable[DatasetLike]) -> tuple[set[Hashable], set[Hashable]]
added: function equivalent_attrs(a: Any, b: Any) -> bool
added: function merge(objects: Iterable[DataTree], compat: CompatOptions | CombineKwargDefault=…, join: JoinOptions | CombineKwargDefault=…, fill_value: object=…, combine_attrs: CombineAttrsOptions=…) -> DataTree | (objects: Iterable[DataArray | Dataset | Coordinates | dict], compat: CompatOptions | CombineKwargDefault=…, join: JoinOptions | CombineKwargDefault=…, fill_value: object=…, combine_attrs: Co…
added: function merge_attrs(variable_attrs, combine_attrs, context=…)
added: function merge_collected(grouped: dict[Any, list[MergeElement]], prioritized: Mapping[Any, MergeElement] | None=…, compat: CompatOptions | CombineKwargDefault=…, combine_attrs: CombineAttrsOptions=…, equals: dict[Any, bool] | None=…) -> tuple[dict[Hashable, Variable], dict[Hashable, Index]]
added: function merge_coordinates_without_align(objects: list[Coordinates], prioritized: Mapping[Any, MergeElement] | None=…, exclude_dims: AbstractSet=…, combine_attrs: CombineAttrsOptions=…) -> tuple[dict[Hashable, Variable], dict[Hashable, Index]]
added: function merge_coords(objects: Iterable[CoercibleMapping], compat: CompatOptions=…, join: JoinOptions=…, priority_arg: int | None=…, indexes: Mapping[Any, Index] | None=…, fill_value: object=…) -> tuple[dict[Hashable, Variable], dict[Hashable, Index]]
added: function merge_core(objects: Iterable[CoercibleMapping], compat: CompatOptions | CombineKwargDefault, join: JoinOptions | CombineKwargDefault, combine_attrs: CombineAttrsOptions=…, priority_arg: int | None=…, explicit_coords: Iterable[Hashable] | None=…, indexes: Mapping[Any, Any] | None=…, fill_value: object=…, skip_align_args: list[int] | None=…) -> _MergeResult
added: function merge_data_and_coords(data_vars: DataVars, coords) -> _MergeResult
added: function merge_trees(trees: Sequence[DataTree], compat: CompatOptions | CombineKwargDefault=…, join: JoinOptions | CombineKwargDefault=…, fill_value: object=…, combine_attrs: CombineAttrsOptions=…) -> DataTree
added: function unique_variable(name: Hashable, variables: list[Variable], compat: CompatOptions | CombineKwargDefault=…, equals: bool | None=…) -> tuple[bool | None, Variable]
added: variable ArrayLike
added: variable CoercibleMapping
added: variable CoercibleValue
added: variable DatasetLike
added: variable DimsLike
added: variable MergeElement
added: variable PANDAS_TYPES
added: variable VariableLike
added: variable XarrayValue

changed: function open_dataset(name: str, cache: bool=…, cache_dir: None | str | os.PathLike=…, *, engine: T_Engine=…, **kws) -> Dataset → function open_dataset(name: str, cache: bool=…, cache_dir: str | os.PathLike | None=…, *, engine: T_Engine=…, **kws) -> Dataset
changed: function scatter_example_dataset(*, seed: None | int=…) -> Dataset → function scatter_example_dataset(*, seed: int | None=…) -> Dataset
added: function load_datatree(*args, **kwargs) -> DataTree
added: function open_datatree(name: str, cache: bool=…, cache_dir: str | os.PathLike | None=…, *, engine: T_Engine=…, **kws) -> DataTree

added: export DataArrayCoarsen
added: export DataArrayGroupBy
added: export DataArrayResample
added: export DataArrayRolling
added: export DataArrayWeighted
added: export DatasetRolling
added: export DatasetWeighted
added: export Weighted

added: class CombineKwargDefault
added: constructor CombineKwargDefault(*, name: str, old: str, new: str | None)
added: method CombineKwargDefault.error_message() -> str
added: method CombineKwargDefault.warning_message(message: str, recommend_set_options: bool=…) -> str

removed: variable ExtraKwarg
added: class ExtraKwarg(NamedTuple)
added: field ExtraKwarg.call: str
added: field ExtraKwarg.docs: str
added: field ExtraKwarg.example: str
added: field ExtraKwarg.kwarg: str