Upgrading xarray 2022 to 2023
Breaking2022.12.0 → 2023.12.0Breaking10Deprecated4New17Changed21Fixed20Other65
BreakingUpgrade verdict
10 breaking changes.
In plain terms
- The .drop method is now fully deprecated and should be replaced with .drop_vars or .drop_sel.
- Removes keep_attrs from the resample signature.
- Removes PseudoNetCDF support.
- Removes cdms2 support.
Must act Top 5 of 14 that need code or config changes
Python requirement changed in 2023.2.0: >=3.8 → >=3.9.
What you must change
Breaking10
Fully deprecates .drop.
.dropRemoves keep_attrs from the resample signature.
resamplekeep_attrsRemoves PseudoNetCDF support.
PseudoNetCDFRemoves cdms2 support.
cdms2Renames reset_encoding to drop_encoding.
reset_encodingdrop_encodingRemoves the real, imag and astype methods from NamedArray.
NamedArrayrealimagastypeDeclares Dataset, DataArray, Variable and GroupBy unhashable.
DatasetDataArrayVariableGroupByRaises an exception in to_dataset if the resulting variable is also the name of a coordinate.
to_datasetMandates keyword arguments on to_zarr.
to_zarrMakes more arguments keyword only, except dim.
dimDeprecations to plan for
Deprecated4
Starts renaming
dims to dim.dimsdimDeprecates ds.dims returning a dict.
ds.dimsDeprecates tuples of chunks.
Deprecates certain cftime frequency strings following pandas.
API changes
Generated by DepDelta from published Python source. Not mixed with prose notes.
- removed:
export Coordinate - removed:
export open_rasterio - added:
export Coordinates - added:
export Index - added:
export IndexSelResult
- removed:
export CfGribDataStore - removed:
export PseudoNetCDFBackendEntrypoint - removed:
export PseudoNetCDFDataStore - added:
export refresh_engines
- removed:
variable T_Chunks - changed:
function open_dataarray(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore, *, engine: T_Engine=…, chunks: T_Chunks=…, 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'] | bool… → function open_dataarray(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | 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',… - changed:
function open_mfdataset(paths: str | NestedSequence[str | os.PathLike], chunks: T_Chunks=…, concat_dim: str | DataArray | Index | Sequence[str] | Sequence[DataArray] | Sequence[Index] | None=…, compat: CompatOptions=…, preprocess: Callable[[Dataset], Dataset] | None=…, engine: T_Engine=…, data_vars: Literal['all', 'minimal', 'different'] | list[str]=…, coords=…, combine: Literal['by_coords', 'nes… → function open_mfdataset(paths: str | NestedSequence[str | os.PathLike], 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'] | list[str]=…, coords=…, combine: Literal['by… - changed:
function to_zarr(dataset: Dataset, store: MutableMapping | str | os.PathLike[str] | None=…, chunk_store: MutableMapping | str | os.PathLike | None=…, mode: Literal['w', 'w-', 'a', 'r+', None]=…, synchronizer=…, group: str | None=…, encoding: Mapping | None=…, compute: Literal[True]=…, consolidated: bool | None=…, append_dim: Hashable | None=…, region: Mapping[str, slice] | None=…, safe_chunks: bo… → 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:
class CfGribArrayWrapper(BackendArray) - removed:
class CfGribDataStore(AbstractDataStore) - removed:
class CfgribfBackendEntrypoint(BackendEntrypoint) - removed:
constructor CfGribArrayWrapper(datastore, array) - removed:
constructor CfGribDataStore(filename, lock=…, **backend_kwargs) - removed:
field CfgribfBackendEntrypoint.available - removed:
method CfGribDataStore.get_attrs() - removed:
method CfGribDataStore.get_dimensions() - removed:
method CfGribDataStore.get_encoding() - removed:
method CfGribDataStore.get_variables() - removed:
method CfGribDataStore.open_store_variable(name, var) - removed:
method CfgribfBackendEntrypoint.guess_can_open(filename_or_obj) - removed:
method CfgribfBackendEntrypoint.open_dataset(filename_or_obj, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables=…, use_cftime=…, decode_timedelta=…, lock=…, indexpath=…, filter_by_keys=…, read_keys=…, encode_cf=…, squeeze=…, time_dims=…) - removed:
variable ECCODES_LOCK
- removed:
field BackendEntrypoint.available: ClassVar[bool] - changed:
method ArrayWriter.sync(compute=…) → method ArrayWriter.sync(compute=…, chunkmanager_store_kwargs=…) - changed:
method BackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) → method BackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool - changed:
method BackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore, drop_variables: str | Iterable[str] | None=…, **kwargs: Any) → method BackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore, *, drop_variables: str | Iterable[str] | None=…, **kwargs: Any) -> Dataset - changed:
variable BACKEND_ENTRYPOINTS: dict[str, type[BackendEntrypoint]] → variable BACKEND_ENTRYPOINTS: dict[str, tuple[str | None, type[BackendEntrypoint]]] - added:
method BackendArray.get_duck_array(dtype: np.typing.DTypeLike=…)
- removed:
field H5netcdfBackendEntrypoint.available - changed:
method H5netcdfBackendEntrypoint.guess_can_open(filename_or_obj) → method H5netcdfBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool - changed:
method H5netcdfBackendEntrypoint.open_dataset(filename_or_obj, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables=…, use_cftime=…, decode_timedelta=…, format=…, group=…, lock=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…) → method H5netcdfBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | 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=…) -> Dataset - changed:
static method H5NetCDFStore.open(filename, mode=…, format=…, group=…, lock=…, autoclose=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…) → static method H5NetCDFStore.open(filename, mode=…, format=…, group=…, lock=…, autoclose=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=…)
- removed:
field NetCDF4BackendEntrypoint.available - changed:
method NetCDF4BackendEntrypoint.guess_can_open(filename_or_obj) → method NetCDF4BackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool - changed:
method NetCDF4BackendEntrypoint.open_dataset(filename_or_obj, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables=…, use_cftime=…, decode_timedelta=…, group=…, mode=…, format=…, clobber=…, diskless=…, persist=…, lock=…, autoclose=…) → method NetCDF4BackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | 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=…, lock=…, autoclose=…) -> Dataset
- changed:
function backends_dict_from_pkg(entrypoints) → function backends_dict_from_pkg(entrypoints: list[EntryPoint]) -> dict[str, type[BackendEntrypoint]] - changed:
function build_engines(entrypoints) -> dict[str, BackendEntrypoint] → function build_engines(entrypoints: EntryPoints) -> dict[str, BackendEntrypoint] - changed:
function detect_parameters(open_dataset) → function detect_parameters(open_dataset: Callable) -> tuple[str, ...] - changed:
function guess_engine(store_spec: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) → function guess_engine(store_spec: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> str | type[BackendEntrypoint] - changed:
function remove_duplicates(entrypoints) → function remove_duplicates(entrypoints: EntryPoints) -> list[EntryPoint] - changed:
function set_missing_parameters(backend_entrypoints) → function set_missing_parameters(backend_entrypoints: dict[str, type[BackendEntrypoint]]) -> None - changed:
function sort_backends(backend_entrypoints) → function sort_backends(backend_entrypoints: dict[str, type[BackendEntrypoint]]) -> dict[str, type[BackendEntrypoint]] - added:
function refresh_engines() -> None - added:
variable EntryPoints
- removed:
class PncArrayWrapper(BackendArray) - removed:
class PseudoNetCDFBackendEntrypoint(BackendEntrypoint) - removed:
class PseudoNetCDFDataStore(AbstractDataStore) - removed:
constructor PncArrayWrapper(variable_name, datastore) - removed:
constructor PseudoNetCDFDataStore(manager, lock=…) - removed:
field PseudoNetCDFBackendEntrypoint.available - removed:
field PseudoNetCDFBackendEntrypoint.description - removed:
field PseudoNetCDFBackendEntrypoint.open_dataset_parameters - removed:
field PseudoNetCDFBackendEntrypoint.url - removed:
method PncArrayWrapper.get_array(needs_lock=…) - removed:
method PseudoNetCDFBackendEntrypoint.open_dataset(filename_or_obj, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables=…, use_cftime=…, decode_timedelta=…, mode=…, lock=…, **format_kwargs) - removed:
method PseudoNetCDFDataStore.close() - removed:
method PseudoNetCDFDataStore.get_attrs() - removed:
method PseudoNetCDFDataStore.get_dimensions() - removed:
method PseudoNetCDFDataStore.get_encoding() - removed:
method PseudoNetCDFDataStore.get_variables() - removed:
method PseudoNetCDFDataStore.open_store_variable(name, var) - removed:
property PseudoNetCDFDataStore.ds - removed:
static method PseudoNetCDFDataStore.open(filename, lock=…, mode=…, **format_kwargs) - removed:
variable PNETCDF_LOCK
- removed:
field PydapBackendEntrypoint.available - changed:
method PydapBackendEntrypoint.guess_can_open(filename_or_obj) → method PydapBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool - changed:
method PydapBackendEntrypoint.open_dataset(filename_or_obj, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables=…, use_cftime=…, decode_timedelta=…, application=…, session=…, output_grid=…, timeout=…, verify=…, user_charset=…) → method PydapBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | 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
- removed:
field PynioBackendEntrypoint.available - changed:
method PynioBackendEntrypoint.open_dataset(filename_or_obj, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables=…, use_cftime=…, decode_timedelta=…, mode=…, lock=…) → method PynioBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, mode=…, lock=…) -> Dataset
- removed:
class RasterioArrayWrapper(BackendArray) - removed:
constructor RasterioArrayWrapper(manager, lock, vrt_params=…) - removed:
function open_rasterio(filename, parse_coordinates=…, chunks=…, cache=…, lock=…, **kwargs) - removed:
property RasterioArrayWrapper.dtype - removed:
property RasterioArrayWrapper.shape -> tuple[int, ...] - removed:
variable RASTERIO_LOCK
- removed:
field ScipyBackendEntrypoint.available - changed:
method ScipyBackendEntrypoint.guess_can_open(filename_or_obj) → method ScipyBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool - changed:
method ScipyBackendEntrypoint.open_dataset(filename_or_obj, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables=…, use_cftime=…, decode_timedelta=…, mode=…, format=…, group=…, mmap=…, lock=…) → method ScipyBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | 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
- removed:
field StoreBackendEntrypoint.available - changed:
method StoreBackendEntrypoint.guess_can_open(filename_or_obj) → method StoreBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool - changed:
method StoreBackendEntrypoint.open_dataset(store, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables=…, use_cftime=…, decode_timedelta=…) → method StoreBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…) -> Dataset
- removed:
field ZarrBackendEntrypoint.available - changed:
constructor ZarrArrayWrapper(variable_name, datastore) → constructor ZarrArrayWrapper(zarr_array) - changed:
constructor ZarrStore(zarr_group, mode=…, consolidate_on_close=…, append_dim=…, write_region=…, safe_chunks=…) → constructor ZarrStore(zarr_group, mode=…, consolidate_on_close=…, append_dim=…, write_region=…, safe_chunks=…, write_empty: bool | None=…, close_store_on_close: bool=…) - changed:
function open_zarr(store, group=…, synchronizer=…, chunks=…, decode_cf=…, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables=…, consolidated=…, overwrite_encoded_chunks=…, chunk_store=…, storage_options=…, decode_timedelta=…, use_cftime=…, zarr_version=…, **kwargs) → function open_zarr(store, group=…, synchronizer=…, chunks=…, decode_cf=…, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables=…, consolidated=…, overwrite_encoded_chunks=…, chunk_store=…, storage_options=…, decode_timedelta=…, use_cftime=…, zarr_version=…, chunked_array_type: str | None=…, from_array_kwargs: dict[str, Any] | None=…, **kwargs) - changed:
method ZarrBackendEntrypoint.guess_can_open(filename_or_obj) → method ZarrBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool - changed:
method ZarrBackendEntrypoint.open_dataset(filename_or_obj, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables=…, use_cftime=…, decode_timedelta=…, group=…, mode=…, synchronizer=…, consolidated=…, chunk_store=…, storage_options=…, stacklevel=…, zarr_version=…) → method ZarrBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | 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=…, stacklevel=…, zarr_version=…) -> Dataset - changed:
static method ZarrStore.open_group(store, mode=…, synchronizer=…, group=…, consolidated=…, consolidate_on_close=…, chunk_store=…, storage_options=…, append_dim=…, write_region=…, safe_chunks=…, stacklevel=…, zarr_version=…) → static method ZarrStore.open_group(store, mode: ZarrWriteModes=…, synchronizer=…, group=…, consolidated=…, consolidate_on_close=…, chunk_store=…, storage_options=…, append_dim=…, write_region=…, safe_chunks=…, stacklevel=…, zarr_version=…, write_empty: bool | None=…)
- changed:
function cftime_range(start=…, end=…, periods=…, freq=…, normalize=…, name=…, closed=…, calendar=…) → function cftime_range(start=…, end=…, periods=…, freq=…, normalize=…, name=…, closed: NoDefault | SideOptions=…, inclusive: None | InclusiveOptions=…, calendar=…) - changed:
function date_range(start=…, end=…, periods=…, freq=…, tz=…, normalize=…, name=…, closed=…, calendar=…, use_cftime=…) → function date_range(start=…, end=…, periods=…, freq=…, tz=…, normalize=…, name=…, closed: NoDefault | SideOptions=…, inclusive: None | InclusiveOptions=…, calendar=…, use_cftime=…)
- changed:
method CFTimeIndex.get_loc(key, method=…, tolerance=…) → method CFTimeIndex.get_loc(key)
- changed:
constructor CFDatetimeCoder(use_cftime=…) → constructor CFDatetimeCoder(use_cftime: bool | None=…) -> None - changed:
function cast_to_int_if_safe(num) → function cast_to_int_if_safe(num) -> np.ndarray - changed:
function cftime_to_nptime(times, raise_on_invalid=…) → function cftime_to_nptime(times, raise_on_invalid: bool=…) -> np.ndarray - changed:
function convert_times(times, date_type, raise_on_invalid=…) → function convert_times(times, date_type, raise_on_invalid: bool=…) -> np.ndarray - changed:
function decode_cf_datetime(num_dates, units, calendar=…, use_cftime=…) → function decode_cf_datetime(num_dates, units: str, calendar: str | None=…, use_cftime: bool | None=…) -> np.ndarray - changed:
function decode_cf_timedelta(num_timedeltas, units) → function decode_cf_timedelta(num_timedeltas, units: str) -> np.ndarray - changed:
function encode_cf_datetime(dates, units=…, calendar=…) → function encode_cf_datetime(dates, units: str | None=…, calendar: str | None=…, dtype: np.dtype | None=…) -> tuple[np.ndarray, str, str] - changed:
function encode_cf_timedelta(timedeltas, units=…) → function encode_cf_timedelta(timedeltas, units: str | None=…, dtype: np.dtype | None=…) -> tuple[np.ndarray, str] - changed:
function format_cftime_datetime(date) → function format_cftime_datetime(date) -> str - changed:
function infer_datetime_units(dates) → function infer_datetime_units(dates) -> str - changed:
function infer_timedelta_units(deltas) → function infer_timedelta_units(deltas) -> str - changed:
method CFDatetimeCoder.decode(variable, name=…) → method CFDatetimeCoder.decode(variable: Variable, name: T_Name=…) -> Variable - changed:
method CFDatetimeCoder.encode(variable, name=…) → method CFDatetimeCoder.encode(variable: Variable, name: T_Name=…) -> Variable - changed:
method CFTimedeltaCoder.decode(variable, name=…) → method CFTimedeltaCoder.decode(variable: Variable, name: T_Name=…) -> Variable - changed:
method CFTimedeltaCoder.encode(variable, name=…) → method CFTimedeltaCoder.encode(variable: Variable, name: T_Name=…) -> Variable - added:
variable T_Name
- changed:
function lazy_elemwise_func(array, func, dtype) → function lazy_elemwise_func(array, func: Callable, dtype: np.typing.DTypeLike) - changed:
function pop_to(source, dest, key, name=…) → function pop_to(source: MutableMapping, dest: MutableMapping, key: Hashable, name: T_Name=…) -> Any - changed:
function safe_setitem(dest, key, value, name=…) → function safe_setitem(dest, key: Hashable, value, name: T_Name=…) - changed:
function unpack_for_decoding(var) → function unpack_for_decoding(var: Variable) -> T_VarTuple - changed:
function unpack_for_encoding(var) → function unpack_for_encoding(var: Variable) -> T_VarTuple - changed:
method CFMaskCoder.decode(variable, name=…) → method CFMaskCoder.decode(variable: Variable, name: T_Name=…) - changed:
method CFMaskCoder.encode(variable, name=…) → method CFMaskCoder.encode(variable: Variable, name: T_Name=…) - changed:
method CFScaleOffsetCoder.decode(variable, name=…) → method CFScaleOffsetCoder.decode(variable: Variable, name: T_Name=…) -> Variable - changed:
method CFScaleOffsetCoder.encode(variable, name=…) → method CFScaleOffsetCoder.encode(variable: Variable, name: T_Name=…) -> Variable - changed:
method UnsignedIntegerCoder.decode(variable, name=…) → method UnsignedIntegerCoder.decode(variable: Variable, name: T_Name=…) -> Variable - changed:
method UnsignedIntegerCoder.encode(variable, name=…) → method UnsignedIntegerCoder.encode(variable: Variable, name: T_Name=…) -> Variable - changed:
method VariableCoder.decode(variable: Variable, name: Hashable=…) -> Variable → method VariableCoder.decode(variable: Variable, name: T_Name=…) -> Variable - changed:
method VariableCoder.encode(variable: Variable, name: Hashable=…) -> Variable → method VariableCoder.encode(variable: Variable, name: T_Name=…) -> Variable - added:
class BoolTypeArray(indexing.ExplicitlyIndexedNDArrayMixin) - added:
class BooleanCoder(VariableCoder) - added:
class DefaultFillvalueCoder(VariableCoder) - added:
class EndianCoder(VariableCoder) - added:
class NativeEndiannessArray(indexing.ExplicitlyIndexedNDArrayMixin) - added:
class NonStringCoder(VariableCoder) - added:
class ObjectVLenStringCoder(VariableCoder) - added:
constructor BoolTypeArray(array) -> None - added:
constructor NativeEndiannessArray(array) -> None - added:
method BooleanCoder.decode(variable: Variable, name: T_Name=…) -> Variable - added:
method BooleanCoder.encode(variable: Variable, name: T_Name=…) -> Variable - added:
method DefaultFillvalueCoder.decode(variable: Variable, name: T_Name=…) -> Variable - added:
method DefaultFillvalueCoder.encode(variable: Variable, name: T_Name=…) -> Variable - added:
method EndianCoder.decode(variable: Variable, name: T_Name=…) -> Variable - added:
method EndianCoder.encode() - added:
method NonStringCoder.decode() - added:
method NonStringCoder.encode(variable: Variable, name: T_Name=…) -> Variable - added:
method ObjectVLenStringCoder.decode(variable: Variable, name: T_Name=…) -> Variable - added:
method ObjectVLenStringCoder.encode() - added:
property BoolTypeArray.dtype -> np.dtype - added:
property NativeEndiannessArray.dtype -> np.dtype - added:
variable T_Name - added:
variable T_VarTuple
- removed:
class BoolTypeArray(indexing.ExplicitlyIndexedNDArrayMixin) - removed:
class NativeEndiannessArray(indexing.ExplicitlyIndexedNDArrayMixin) - removed:
constructor BoolTypeArray(array) - removed:
constructor NativeEndiannessArray(array) - removed:
function maybe_default_fill_value(var) - removed:
function maybe_encode_bools(var) - removed:
function maybe_encode_nonstring_dtype(var, name=…) - removed:
property BoolTypeArray.dtype - removed:
property NativeEndiannessArray.dtype - changed:
function cf_decoder(variables, attributes, concat_characters=…, mask_and_scale=…, decode_times=…) → function cf_decoder(variables: T_Variables, attributes: T_Attrs, concat_characters: bool=…, mask_and_scale: bool=…, decode_times: bool=…) -> tuple[T_Variables, T_Attrs] - changed:
function decode_cf(obj, concat_characters=…, mask_and_scale=…, decode_times=…, decode_coords=…, drop_variables=…, use_cftime=…, decode_timedelta=…) → 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 - changed:
function decode_cf_variable(name, var, concat_characters=…, mask_and_scale=…, decode_times=…, decode_endianness=…, stack_char_dim=…, use_cftime=…, decode_timedelta=…) → 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 - changed:
function decode_cf_variables(variables, attributes, concat_characters=…, mask_and_scale=…, decode_times=…, decode_coords=…, drop_variables=…, use_cftime=…, decode_timedelta=…) → function decode_cf_variables(variables: T_Variables, attributes: T_Attrs, 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=…) -> tuple[T_Variables, T_Attrs, set[Hashable]] - changed:
function encode_cf_variable(var, needs_copy=…, name=…) → function encode_cf_variable(var: Variable, needs_copy: bool=…, name: T_Name=…) -> Variable - changed:
function ensure_dtype_not_object(var, name=…) → function ensure_dtype_not_object(var: Variable, name: T_Name=…) -> Variable - changed:
function ensure_not_multiindex(var, name=…) → function ensure_not_multiindex(var: Variable, name: T_Name=…) -> None - added:
variable T_Attrs - added:
variable T_DatasetOrAbstractstore - added:
variable T_DropVariables - added:
variable T_Name - added:
variable T_VarTuple - added:
variable T_Variables
- removed:
function from_cdms2(variable) - removed:
function to_cdms2(dataarray, copy=…) - removed:
variable cdms2_ignored_attrs
- added:
method TimedeltaAccessor.total_seconds() -> T_DataArray
- removed:
variable DataAlignable - changed:
class Aligner(Generic[DataAlignable]) → class Aligner(Generic[T_Alignable]) - changed:
constructor Aligner(objects: Iterable[DataAlignable], join: str=…, indexes: Mapping[Any, Any] | None=…, exclude_dims: Iterable=…, exclude_vars: Iterable[Hashable]=…, method: str | None=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value: Any=…, sparse: bool=…) → 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: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value: Any=…, sparse: bool=…) - changed:
field Aligner.objects: tuple[DataAlignable, ...] → field Aligner.objects: tuple[T_Alignable, ...] - changed:
field Aligner.results: tuple[DataAlignable, ...] → field Aligner.results: tuple[T_Alignable, ...] - changed:
function align(*objects: DataAlignable, join: JoinOptions=…, copy: bool=…, indexes=…, exclude=…, fill_value=…) -> tuple[DataAlignable, ...] → 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… - changed:
function broadcast(*args: T_DataWithCoords, exclude=…) -> tuple[T_DataWithCoords, ...] → 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, /, *,… - changed:
function deep_align(objects: Iterable[Any], join: JoinOptions=…, copy=…, indexes=…, exclude=…, raise_on_invalid=…, fill_value=…) → function deep_align(objects: Iterable[Any], join: JoinOptions=…, copy: bool=…, indexes=…, exclude: str | Iterable[Hashable]=…, raise_on_invalid: bool=…, fill_value=…) -> list[Any] - changed:
function reindex(obj: DataAlignable, indexers: Mapping[Any, Any], method: str | None=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value: Any=…, sparse: bool=…, exclude_vars: Iterable[Hashable]=…) -> DataAlignable → function reindex(obj: T_Alignable, indexers: Mapping[Any, Any], method: str | None=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value: Any=…, sparse: bool=…, exclude_vars: Iterable[Hashable]=…) -> T_Alignable - changed:
function reindex_like(obj: DataAlignable, other: Dataset | DataArray, method: str | None=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value: Any=…) -> DataAlignable → function reindex_like(obj: T_Alignable, other: Dataset | DataArray, method: str | None=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value: Any=…) -> T_Alignable - added:
variable T_Obj1 - added:
variable T_Obj2 - added:
variable T_Obj3 - added:
variable T_Obj4 - added:
variable T_Obj5
- changed:
class VariableArithmetic(ImplementsArrayReduce, IncludeReduceMethods, IncludeCumMethods, IncludeNumpySameMethods, SupportsArithmetic, VariableOpsMixin) → class VariableArithmetic(ImplementsArrayReduce, IncludeNumpySameMethods, SupportsArithmetic, VariableOpsMixin)
- changed:
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=…, datasets: Iterable[Dataset] | None=…) -> Dataset | DataArray → 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:
property AbstractArray.sizes -> Frozen[Hashable, int] - changed:
function contains_cftime_datetimes(var) -> bool → function contains_cftime_datetimes(var: T_Variable) -> bool - changed:
function full_like(other: DataArray, fill_value: Any, dtype: DTypeLikeSave=…) -> DataArray | (other: Dataset, fill_value: Any, dtype: DTypeMaybeMapping=…) -> Dataset | (other: Variable, fill_value: Any, dtype: DTypeLikeSave=…) -> Variable | (other: Dataset | DataArray, fill_value: Any, dtype: DTypeMaybeMapping=…) -> Dataset | DataArray | (other: Dataset | DataArray | Variable, fill_value: Any, dt… → function full_like(other: DataArray, fill_value: Any, dtype: DTypeLikeSave | None=…, *, chunks: T_Chunks=…, chunked_array_type: str | None=…, from_array_kwargs: dict[str, Any] | None=…) -> DataArray | (other: Dataset, fill_value: Any, dtype: DTypeMaybeMapping | None=…, *, chunks: T_Chunks=…, chunked_array_type: str | None=…, from_array_kwargs: dict[str, Any] | None=…) -> Dataset | (other: Variabl… - changed:
function ones_like(other: DataArray, dtype: DTypeLikeSave=…) -> DataArray | (other: Dataset, dtype: DTypeMaybeMapping=…) -> Dataset | (other: Variable, dtype: DTypeLikeSave=…) -> Variable | (other: Dataset | DataArray, dtype: DTypeMaybeMapping=…) -> Dataset | DataArray | (other: Dataset | DataArray | Variable, dtype: DTypeMaybeMapping=…) -> Dataset | DataArray | Variable → function ones_like(other: DataArray, dtype: DTypeLikeSave | None=…, *, chunks: T_Chunks=…, chunked_array_type: str | None=…, from_array_kwargs: dict[str, Any] | None=…) -> DataArray | (other: Dataset, dtype: DTypeMaybeMapping | None=…, *, chunks: T_Chunks=…, chunked_array_type: str | None=…, from_array_kwargs: dict[str, Any] | None=…) -> Dataset | (other: Variable, dtype: DTypeLikeSave | None=…,… - changed:
function zeros_like(other: DataArray, dtype: DTypeLikeSave=…) -> DataArray | (other: Dataset, dtype: DTypeMaybeMapping=…) -> Dataset | (other: Variable, dtype: DTypeLikeSave=…) -> Variable | (other: Dataset | DataArray, dtype: DTypeMaybeMapping=…) -> Dataset | DataArray | (other: Dataset | DataArray | Variable, dtype: DTypeMaybeMapping=…) -> Dataset | DataArray | Variable → function zeros_like(other: DataArray, dtype: DTypeLikeSave | None=…, *, chunks: T_Chunks=…, chunked_array_type: str | None=…, from_array_kwargs: dict[str, Any] | None=…) -> DataArray | (other: Dataset, dtype: DTypeMaybeMapping | None=…, *, chunks: T_Chunks=…, chunked_array_type: str | None=…, from_array_kwargs: dict[str, Any] | None=…) -> Dataset | (other: Variable, dtype: DTypeLikeSave | None=…,… - changed:
method DataWithCoords.assign_attrs(*args: Any, **kwargs: Any) -> T_DataWithCoords → method DataWithCoords.assign_attrs(*args: Any, **kwargs: Any) -> Self - changed:
method DataWithCoords.assign_coords(coords: Mapping[Any, Any] | None=…, **coords_kwargs: Any) -> T_DataWithCoords → method DataWithCoords.assign_coords(coords: Mapping | None=…, **coords_kwargs: Any) -> Self - changed:
method DataWithCoords.astype(dtype, *, order=…, casting=…, subok=…, copy=…, keep_attrs=…) -> T_DataWithCoords → method DataWithCoords.astype(dtype, *, order=…, casting=…, subok=…, copy=…, keep_attrs=…) -> Self - changed:
method DataWithCoords.clip(min: ScalarOrArray | None=…, max: ScalarOrArray | None=…, *, keep_attrs: bool | None=…) -> T_DataWithCoords → method DataWithCoords.clip(min: ScalarOrArray | None=…, max: ScalarOrArray | None=…, *, keep_attrs: bool | None=…) -> Self - changed:
method DataWithCoords.isin(test_elements: Any) -> T_DataWithCoords → method DataWithCoords.isin(test_elements: Any) -> Self - changed:
method DataWithCoords.isnull(keep_attrs: bool | None=…) -> T_DataWithCoords → method DataWithCoords.isnull(keep_attrs: bool | None=…) -> Self - changed:
method DataWithCoords.notnull(keep_attrs: bool | None=…) -> T_DataWithCoords → method DataWithCoords.notnull(keep_attrs: bool | None=…) -> Self - changed:
method DataWithCoords.squeeze(dim: Hashable | Iterable[Hashable] | None=…, drop: bool=…, axis: int | Iterable[int] | None=…) -> T_DataWithCoords → method DataWithCoords.squeeze(dim: Hashable | Iterable[Hashable] | None=…, drop: bool=…, axis: int | Iterable[int] | None=…) -> Self - changed:
method DataWithCoords.where(cond: Any, other: Any=…, drop: bool=…) -> T_DataWithCoords → method DataWithCoords.where(cond: Any, other: Any=…, drop: bool=…) -> Self - added:
property AbstractArray.sizes -> Mapping[Hashable, int]
- changed:
function apply_dataset_vfunc(func, *args, signature: _UFuncSignature, join=…, dataset_join=…, fill_value=…, exclude_dims=…, keep_attrs=…) -> Dataset | tuple[Dataset, ...] → 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, ...] - changed:
function apply_dict_of_variables_vfunc(func, *args, signature: _UFuncSignature, join=…, fill_value=…) → function apply_dict_of_variables_vfunc(func, *args, signature: _UFuncSignature, join=…, fill_value=…, on_missing_core_dim: MissingCoreDimOptions=…) - changed:
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: str=…, output_dtypes: Sequence | None=…, output_sizes: Mapping[Any, int]… → 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… - changed:
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]]] → 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]]] - changed:
function corr(da_a, da_b, dim=…) → function corr(da_a: T_DataArray, da_b: T_DataArray, dim: Dims=…) -> T_DataArray - changed:
function cov(da_a, da_b, dim=…, ddof=…) → function cov(da_a: T_DataArray, da_b: T_DataArray, dim: Dims=…, ddof: int=…) -> T_DataArray - changed:
function dot(*arrays, dims: str | Iterable[Hashable] | ellipsis | None=…, **kwargs: Any) → function dot(*arrays, dim: Dims=…, **kwargs: Any) - changed:
function unified_dim_sizes(variables: Iterable[Variable], exclude_dims: AbstractSet=…) -> dict[Hashable, int] → function unified_dim_sizes(variables: Iterable[Variable], exclude_dims: Set=…) -> dict[Hashable, int] - added:
variable MissingCoreDimOptions
- changed:
function concat(objs: Iterable[T_Dataset], dim: Hashable | T_DataArray | pd.Index, data_vars: ConcatOptions | list[Hashable]=…, coords: ConcatOptions | list[Hashable]=…, compat: CompatOptions=…, positions: Iterable[Iterable[int]] | None=…, fill_value: object=…, join: JoinOptions=…, combine_attrs: CombineAttrsOptions=…) -> T_Dataset | (objs: Iterable[T_DataArray], dim: Hashable | T_DataArray | pd.… → function concat(objs: Iterable[T_Dataset], dim: Hashable | T_Variable | T_DataArray | pd.Index, data_vars: T_DataVars=…, coords: ConcatOptions | list[Hashable]=…, compat: CompatOptions=…, positions: Iterable[Iterable[int]] | None=…, fill_value: object=…, join: JoinOptions=…, combine_attrs: CombineAttrsOptions=…) -> T_Dataset | (objs: Iterable[T_DataArray], dim: Hashable | T_Variable | T_DataArray… - added:
variable T_DataVars
- removed:
function drop_coords(coords_to_drop: set[Hashable], variables, indexes: Indexes) -> tuple[dict, dict] - removed:
method Coordinates.to_index(ordered_dims: Sequence[Hashable] | None=…) -> pd.Index - removed:
property Coordinates.dims -> Mapping[Hashable, int] | tuple[Hashable, ...] - removed:
property Coordinates.indexes -> Indexes[pd.Index] - removed:
property Coordinates.variables - removed:
property Coordinates.xindexes -> Indexes[Index] - removed:
property DatasetCoordinates.dims -> Mapping[Hashable, int] - removed:
variable GenericAlias - changed:
class Coordinates(Mapping[Hashable, 'T_DataArray']) → class Coordinates(AbstractCoordinates) - changed:
class DataArrayCoordinates(Coordinates['T_DataArray']) → class DataArrayCoordinates(Coordinates, Generic[T_DataArray]) - changed:
function assert_coordinate_consistent(obj: T_DataArray | Dataset, coords: Mapping[Any, Variable]) -> None → function assert_coordinate_consistent(obj: T_Xarray, coords: Mapping[Any, Variable]) -> None - changed:
method Coordinates.merge(other: Coordinates | None) -> Dataset → method Coordinates.merge(other: Mapping[Any, Any] | None) -> Dataset - added:
class AbstractCoordinates(Mapping[Hashable, 'T_DataArray']) - added:
constructor Coordinates(coords: Mapping[Any, Any] | None=…, indexes: Mapping[Any, Index] | None=…) -> None - added:
function create_coords_with_default_indexes(coords: Mapping[Any, Any], data_vars: DataVars | None=…) -> Coordinates - added:
function drop_indexed_coords(coords_to_drop: set[Hashable], coords: Coordinates) -> Coordinates - added:
method AbstractCoordinates.to_dataset() -> Dataset - added:
method AbstractCoordinates.to_index(ordered_dims: Sequence[Hashable] | None=…) -> pd.Index - added:
method Coordinates.assign(coords: Mapping | None=…, **coords_kwargs: Any) -> Self - added:
method Coordinates.copy(deep: bool=…, memo: dict[int, Any] | None=…) -> Self - added:
method Coordinates.equals(other: Self) -> bool - added:
method Coordinates.identical(other: Self) -> bool - added:
property AbstractCoordinates.dims -> Frozen[Hashable, int] | tuple[Hashable, ...] - added:
property AbstractCoordinates.dtypes -> Frozen[Hashable, np.dtype] - added:
property AbstractCoordinates.indexes -> Indexes[pd.Index] - added:
property AbstractCoordinates.variables - added:
property AbstractCoordinates.xindexes -> Indexes[Index] - added:
property Coordinates.dims -> Frozen[Hashable, int] | tuple[Hashable, ...] - added:
property Coordinates.sizes -> Frozen[Hashable, int] - added:
property Coordinates.variables -> Mapping[Hashable, Variable] - added:
property DatasetCoordinates.dims -> Frozen[Hashable, int] - added:
static method Coordinates.from_pandas_multiindex(midx: pd.MultiIndex, dim: str) -> Self
- added:
class DaskManager(ChunkManagerEntrypoint['DaskArray']) - added:
constructor DaskManager() -> None - added:
field DaskManager.array_cls: type[DaskArray] - added:
field DaskManager.available: bool - added:
method DaskManager.apply_gufunc(func: Callable, signature: str, *args: Any, axes: Sequence[tuple[int, ...]] | None=…, axis: int | None=…, keepdims: bool=…, output_dtypes: Sequence[np.typing.DTypeLike] | None=…, output_sizes: dict[str, int] | None=…, vectorize: bool | None=…, allow_rechunk: bool=…, meta: tuple[np.ndarray, ...] | None=…, **kwargs) - added:
method DaskManager.blockwise(func: Callable, out_ind: Iterable, *args: Any, name: str | None=…, token=…, dtype: np.dtype | None=…, adjust_chunks: dict[Any, Callable] | None=…, new_axes: dict[Any, int] | None=…, align_arrays: bool=…, concatenate: bool | None=…, meta=…, **kwargs) - added:
method DaskManager.chunks(data: DaskArray) -> T_NormalizedChunks - added:
method DaskManager.compute(*data: DaskArray, **kwargs) -> tuple[np.ndarray, ...] - added:
method DaskManager.from_array(data: Any, chunks, **kwargs) -> DaskArray - added:
method DaskManager.is_chunked_array(data: Any) -> bool - added:
method DaskManager.map_blocks(func: Callable, *args: Any, dtype: np.typing.DTypeLike | None=…, chunks: tuple[int, ...] | None=…, drop_axis: int | Sequence[int] | None=…, new_axis: int | Sequence[int] | None=…, **kwargs) - added:
method DaskManager.normalize_chunks(chunks: T_Chunks | T_NormalizedChunks, shape: tuple[int, ...] | None=…, limit: int | None=…, dtype: np.dtype | None=…, previous_chunks: T_NormalizedChunks | None=…) -> T_NormalizedChunks - added:
method DaskManager.reduction(arr: T_ChunkedArray, func: Callable, combine_func: Callable | None=…, aggregate_func: Callable | None=…, axis: int | Sequence[int] | None=…, dtype: np.dtype | None=…, keepdims: bool=…) -> T_ChunkedArray - added:
method DaskManager.store(sources: DaskArray | Sequence[DaskArray], targets: Any, **kwargs) - added:
method DaskManager.unify_chunks(*args: Any, **kwargs) -> tuple[dict[str, T_NormalizedChunks], list[DaskArray]] - added:
property DaskManager.array_api -> Any
- removed:
method DataArray.to_cdms2() -> cdms2_Variable - removed:
property DataArray.T -> T_DataArray - removed:
property DataArray.imag -> T_DataArray - removed:
property DataArray.real -> T_DataArray - removed:
static method DataArray.from_cdms2(variable: cdms2_Variable) -> DataArray - removed:
variable cdms2_Variable - changed:
constructor DataArray(data: Any=…, coords: Sequence[Sequence[Any] | pd.Index | DataArray] | Mapping[Any, Any] | None=…, dims: Hashable | Sequence[Hashable] | None=…, name: Hashable | None=…, attrs: Mapping | None=…, indexes: dict[Hashable, Index] | None=…, fastpath: bool=…) -> None → constructor DataArray(data: Any=…, coords: Sequence[Sequence[Any] | pd.Index | DataArray] | Mapping[Any, Any] | None=…, dims: Hashable | Sequence[Hashable] | None=…, name: Hashable | None=…, attrs: Mapping | None=…, indexes: Mapping[Any, Index] | None=…, fastpath: bool=…) -> None - changed:
method DataArray.argmax(dim: Dims=…, axis: int | None=…, keep_attrs: bool | None=…, skipna: bool | None=…) -> DataArray | dict[Hashable, DataArray] → method DataArray.argmax(dim: Dims=…, *, axis: int | None=…, keep_attrs: bool | None=…, skipna: bool | None=…) -> Self | dict[Hashable, Self] - changed:
method DataArray.argmin(dim: Dims=…, axis: int | None=…, keep_attrs: bool | None=…, skipna: bool | None=…) -> DataArray | dict[Hashable, DataArray] → method DataArray.argmin(dim: Dims=…, *, axis: int | None=…, keep_attrs: bool | None=…, skipna: bool | None=…) -> Self | dict[Hashable, Self] - changed:
method DataArray.as_numpy() -> T_DataArray → method DataArray.as_numpy() -> Self - changed:
method DataArray.bfill(dim: Hashable, limit: int | None=…) -> T_DataArray → method DataArray.bfill(dim: Hashable, limit: int | None=…) -> Self - changed:
method DataArray.broadcast_equals(other: T_DataArray) -> bool → method DataArray.broadcast_equals(other: Self) -> bool - changed:
method DataArray.broadcast_like(other: DataArray | Dataset, exclude: Iterable[Hashable] | None=…) -> T_DataArray → method DataArray.broadcast_like(other: T_DataArrayOrSet, *, exclude: Iterable[Hashable] | None=…) -> Self - changed:
method DataArray.chunk(chunks: int | Literal['auto'] | tuple[int, ...] | tuple[tuple[int, ...], ...] | Mapping[Any, None | int | tuple[int, ...]]=…, name_prefix: str=…, token: str | None=…, lock: bool=…, inline_array: bool=…, **chunks_kwargs: Any) -> T_DataArray → method DataArray.chunk(chunks: T_Chunks=…, *, name_prefix: str=…, token: str | None=…, lock: bool=…, inline_array: bool=…, chunked_array_type: str | ChunkManagerEntrypoint | None=…, from_array_kwargs=…, **chunks_kwargs: Any) -> Self - changed:
method DataArray.combine_first(other: T_DataArray) -> T_DataArray → method DataArray.combine_first(other: Self) -> Self - changed:
method DataArray.compute(**kwargs) -> T_DataArray → method DataArray.compute(**kwargs) -> Self - changed:
method DataArray.convert_calendar(calendar: str, dim: str=…, align_on: str | None=…, missing: Any | None=…, use_cftime: bool | None=…) -> DataArray → method DataArray.convert_calendar(calendar: str, dim: str=…, align_on: str | None=…, missing: Any | None=…, use_cftime: bool | None=…) -> Self - changed:
method DataArray.copy(deep: bool=…, data: Any=…) -> T_DataArray → method DataArray.copy(deep: bool=…, data: Any=…) -> Self - changed:
method DataArray.cumulative_integrate(coord: Hashable | Sequence[Hashable]=…, datetime_unit: DatetimeUnitOptions=…) -> DataArray → method DataArray.cumulative_integrate(coord: Hashable | Sequence[Hashable]=…, datetime_unit: DatetimeUnitOptions=…) -> Self - changed:
method DataArray.curvefit(coords: str | DataArray | Iterable[str | DataArray], func: Callable[..., Any], reduce_dims: Dims=…, skipna: bool=…, p0: dict[str, Any] | None=…, bounds: dict[str, Any] | None=…, param_names: Sequence[str] | None=…, kwargs: dict[str, Any] | None=…) -> Dataset → method DataArray.curvefit(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=…) -> Dataset - changed:
method DataArray.diff(dim: Hashable, n: int=…, label: Literal['upper', 'lower']=…) -> T_DataArray → method DataArray.diff(dim: Hashable, n: int=…, *, label: Literal['upper', 'lower']=…) -> Self - changed:
method DataArray.differentiate(coord: Hashable, edge_order: Literal[1, 2]=…, datetime_unit: DatetimeUnitOptions=…) -> T_DataArray → method DataArray.differentiate(coord: Hashable, edge_order: Literal[1, 2]=…, datetime_unit: DatetimeUnitOptions=…) -> Self - changed:
method DataArray.dot(other: T_DataArray, dims: Dims=…) -> T_DataArray → method DataArray.dot(other: T_Xarray, dim: Dims=…) -> T_Xarray - changed:
method DataArray.drop(labels: Mapping[Any, Any] | None=…, dim: Hashable | None=…, *, errors: ErrorOptions=…, **labels_kwargs) -> T_DataArray → method DataArray.drop(labels: Mapping[Any, Any] | None=…, dim: Hashable | None=…, *, errors: ErrorOptions=…, **labels_kwargs) -> Self - changed:
method DataArray.drop_duplicates(dim: Hashable | Iterable[Hashable], keep: Literal['first', 'last', False]=…) -> T_DataArray → method DataArray.drop_duplicates(dim: Hashable | Iterable[Hashable], *, keep: Literal['first', 'last', False]=…) -> Self - changed:
method DataArray.drop_indexes(coord_names: Hashable | Iterable[Hashable], *, errors: ErrorOptions=…) -> T_DataArray → method DataArray.drop_indexes(coord_names: Hashable | Iterable[Hashable], *, errors: ErrorOptions=…) -> Self - changed:
method DataArray.drop_isel(indexers: Mapping[Any, Any] | None=…, **indexers_kwargs) -> T_DataArray → method DataArray.drop_isel(indexers: Mapping[Any, Any] | None=…, **indexers_kwargs) -> Self - changed:
method DataArray.drop_sel(labels: Mapping[Any, Any] | None=…, *, errors: ErrorOptions=…, **labels_kwargs) -> T_DataArray → method DataArray.drop_sel(labels: Mapping[Any, Any] | None=…, *, errors: ErrorOptions=…, **labels_kwargs) -> Self - changed:
method DataArray.drop_vars(names: Hashable | Iterable[Hashable], *, errors: ErrorOptions=…) -> DataArray → method DataArray.drop_vars(names: str | Iterable[Hashable] | Callable[[Self], str | Iterable[Hashable]], *, errors: ErrorOptions=…) -> Self - changed:
method DataArray.dropna(dim: Hashable, how: Literal['any', 'all']=…, thresh: int | None=…) -> T_DataArray → method DataArray.dropna(dim: Hashable, *, how: Literal['any', 'all']=…, thresh: int | None=…) -> Self - changed:
method DataArray.equals(other: T_DataArray) -> bool → method DataArray.equals(other: Self) -> bool - changed:
method DataArray.expand_dims(dim: None | Hashable | Sequence[Hashable] | Mapping[Any, Any]=…, axis: None | int | Sequence[int]=…, **dim_kwargs: Any) -> DataArray → method DataArray.expand_dims(dim: None | Hashable | Sequence[Hashable] | Mapping[Any, Any]=…, axis: None | int | Sequence[int]=…, **dim_kwargs: Any) -> Self - changed:
method DataArray.ffill(dim: Hashable, limit: int | None=…) -> T_DataArray → method DataArray.ffill(dim: Hashable, limit: int | None=…) -> Self - changed:
method DataArray.fillna(value: Any) -> T_DataArray → method DataArray.fillna(value: Any) -> Self - changed:
method DataArray.head(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> T_DataArray → method DataArray.head(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> Self - changed:
method DataArray.identical(other: T_DataArray) -> bool → method DataArray.identical(other: Self) -> bool - changed:
method DataArray.idxmax(dim: Hashable=…, skipna: bool | None=…, fill_value: Any=…, keep_attrs: bool | None=…) -> DataArray → method DataArray.idxmax(dim: Hashable=…, *, skipna: bool | None=…, fill_value: Any=…, keep_attrs: bool | None=…) -> Self - changed:
method DataArray.idxmin(dim: Hashable | None=…, skipna: bool | None=…, fill_value: Any=…, keep_attrs: bool | None=…) -> DataArray → method DataArray.idxmin(dim: Hashable | None=…, *, skipna: bool | None=…, fill_value: Any=…, keep_attrs: bool | None=…) -> Self - changed:
method DataArray.integrate(coord: Hashable | Sequence[Hashable]=…, datetime_unit: DatetimeUnitOptions=…) -> DataArray → method DataArray.integrate(coord: Hashable | Sequence[Hashable]=…, datetime_unit: DatetimeUnitOptions=…) -> Self - changed:
method DataArray.interp(coords: Mapping[Any, Any] | None=…, method: InterpOptions=…, assume_sorted: bool=…, kwargs: Mapping[str, Any] | None=…, **coords_kwargs: Any) -> T_DataArray → method DataArray.interp(coords: Mapping[Any, Any] | None=…, method: InterpOptions=…, assume_sorted: bool=…, kwargs: Mapping[str, Any] | None=…, **coords_kwargs: Any) -> Self - changed:
method DataArray.interp_calendar(target: pd.DatetimeIndex | CFTimeIndex | DataArray, dim: str=…) -> DataArray → method DataArray.interp_calendar(target: pd.DatetimeIndex | CFTimeIndex | DataArray, dim: str=…) -> Self - changed:
method DataArray.interp_like(other: DataArray | Dataset, method: InterpOptions=…, assume_sorted: bool=…, kwargs: Mapping[str, Any] | None=…) -> T_DataArray → method DataArray.interp_like(other: T_Xarray, method: InterpOptions=…, assume_sorted: bool=…, kwargs: Mapping[str, Any] | None=…) -> Self - changed:
method DataArray.interpolate_na(dim: Hashable | None=…, method: InterpOptions=…, limit: int | None=…, use_coordinate: bool | str=…, max_gap: None | int | float | str | pd.Timedelta | np.timedelta64 | datetime.timedelta=…, keep_attrs: bool | None=…, **kwargs: Any) -> T_DataArray → method DataArray.interpolate_na(dim: Hashable | None=…, method: InterpOptions=…, limit: int | None=…, use_coordinate: bool | str=…, max_gap: None | int | float | str | pd.Timedelta | np.timedelta64 | datetime.timedelta=…, keep_attrs: bool | None=…, **kwargs: Any) -> Self - changed:
method DataArray.isel(indexers: Mapping[Any, Any] | None=…, drop: bool=…, missing_dims: ErrorOptionsWithWarn=…, **indexers_kwargs: Any) -> T_DataArray → method DataArray.isel(indexers: Mapping[Any, Any] | None=…, drop: bool=…, missing_dims: ErrorOptionsWithWarn=…, **indexers_kwargs: Any) -> Self - changed:
method DataArray.load(**kwargs) -> T_DataArray → method DataArray.load(**kwargs) -> Self - changed:
method DataArray.pad(pad_width: Mapping[Any, int | tuple[int, int]] | None=…, mode: PadModeOptions=…, stat_length: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, constant_values: float | tuple[float, float] | Mapping[Any, tuple[float, float]] | None=…, end_values: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, reflect_type: PadReflectOptions=…, **pad_width_kwargs… → method DataArray.pad(pad_width: Mapping[Any, int | tuple[int, int]] | None=…, mode: PadModeOptions=…, stat_length: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, constant_values: float | tuple[float, float] | Mapping[Any, tuple[float, float]] | None=…, end_values: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, reflect_type: PadReflectOptions=…, keep_attrs: bool |… - changed:
method DataArray.persist(**kwargs) -> T_DataArray → method DataArray.persist(**kwargs) -> Self - changed:
method DataArray.quantile(q: ArrayLike, dim: Dims=…, method: QuantileMethods=…, keep_attrs: bool | None=…, skipna: bool | None=…, interpolation: QuantileMethods | None=…) -> T_DataArray → method DataArray.quantile(q: ArrayLike, dim: Dims=…, *, method: QuantileMethods=…, keep_attrs: bool | None=…, skipna: bool | None=…, interpolation: QuantileMethods | None=…) -> Self - changed:
method DataArray.rank(dim: Hashable, pct: bool=…, keep_attrs: bool | None=…) -> T_DataArray → method DataArray.rank(dim: Hashable, *, pct: bool=…, keep_attrs: bool | None=…) -> Self - changed:
method DataArray.reduce(func: Callable[..., Any], dim: Dims=…, *, axis: int | Sequence[int] | None=…, keep_attrs: bool | None=…, keepdims: bool=…, **kwargs: Any) -> T_DataArray → method DataArray.reduce(func: Callable[..., Any], dim: Dims=…, *, axis: int | Sequence[int] | None=…, keep_attrs: bool | None=…, keepdims: bool=…, **kwargs: Any) -> Self - changed:
method DataArray.reindex(indexers: Mapping[Any, Any] | None=…, method: ReindexMethodOptions=…, tolerance: float | Iterable[float] | None=…, copy: bool=…, fill_value=…, **indexers_kwargs: Any) -> T_DataArray → method DataArray.reindex(indexers: Mapping[Any, Any] | None=…, *, method: ReindexMethodOptions=…, tolerance: float | Iterable[float] | None=…, copy: bool=…, fill_value=…, **indexers_kwargs: Any) -> Self - changed:
method DataArray.reindex_like(other: DataArray | Dataset, method: ReindexMethodOptions=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value=…) -> T_DataArray → method DataArray.reindex_like(other: T_DataArrayOrSet, *, method: ReindexMethodOptions=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value=…) -> Self - changed:
method DataArray.rename(new_name_or_name_dict: Hashable | Mapping[Any, Hashable] | None=…, **names: Hashable) -> DataArray → method DataArray.rename(new_name_or_name_dict: Hashable | Mapping[Any, Hashable] | None=…, **names: Hashable) -> Self - changed:
method DataArray.reorder_levels(dim_order: Mapping[Any, Sequence[int | Hashable]] | None=…, **dim_order_kwargs: Sequence[int | Hashable]) -> T_DataArray → method DataArray.reorder_levels(dim_order: Mapping[Any, Sequence[int | Hashable]] | None=…, **dim_order_kwargs: Sequence[int | Hashable]) -> Self - changed:
method DataArray.resample(indexer: Mapping[Any, str] | None=…, skipna: bool | None=…, closed: SideOptions | None=…, label: SideOptions | None=…, base: int | None=…, offset: pd.Timedelta | datetime.timedelta | str | None=…, origin: str | DatetimeLike=…, keep_attrs: bool | None=…, loffset: datetime.timedelta | str | None=…, restore_coord_dims: bool | None=…, **indexer_kwargs: str) -> DataArrayResam… → method DataArray.resample(indexer: Mapping[Any, str] | None=…, skipna: bool | None=…, closed: SideOptions | None=…, label: SideOptions | None=…, base: int | None=…, offset: pd.Timedelta | datetime.timedelta | str | None=…, origin: str | DatetimeLike=…, loffset: datetime.timedelta | str | None=…, restore_coord_dims: bool | None=…, **indexer_kwargs: str) -> DataArrayResample - changed:
method DataArray.reset_coords(names: Dims=…, drop: Literal[False]=…) -> Dataset | (names: Dims=…, *, drop: Literal[True]) -> T_DataArray → method DataArray.reset_coords(names: Dims=…, *, drop: Literal[False]=…) -> Dataset | (names: Dims=…, *, drop: Literal[True]) -> Self - changed:
method DataArray.reset_index(dims_or_levels: Hashable | Sequence[Hashable], drop: bool=…) -> DataArray → method DataArray.reset_index(dims_or_levels: Hashable | Sequence[Hashable], drop: bool=…) -> Self - changed:
method DataArray.roll(shifts: Mapping[Hashable, int] | None=…, roll_coords: bool=…, **shifts_kwargs: int) -> T_DataArray → method DataArray.roll(shifts: Mapping[Hashable, int] | None=…, roll_coords: bool=…, **shifts_kwargs: int) -> Self - changed:
method DataArray.sel(indexers: Mapping[Any, Any] | None=…, method: str | None=…, tolerance=…, drop: bool=…, **indexers_kwargs: Any) -> T_DataArray → method DataArray.sel(indexers: Mapping[Any, Any] | None=…, method: str | None=…, tolerance=…, drop: bool=…, **indexers_kwargs: Any) -> Self - changed:
method DataArray.set_index(indexes: Mapping[Any, Hashable | Sequence[Hashable]] | None=…, append: bool=…, **indexes_kwargs: Hashable | Sequence[Hashable]) -> DataArray → method DataArray.set_index(indexes: Mapping[Any, Hashable | Sequence[Hashable]] | None=…, append: bool=…, **indexes_kwargs: Hashable | Sequence[Hashable]) -> Self - changed:
method DataArray.set_xindex(coord_names: str | Sequence[Hashable], index_cls: type[Index] | None=…, **options) -> T_DataArray → method DataArray.set_xindex(coord_names: str | Sequence[Hashable], index_cls: type[Index] | None=…, **options) -> Self - changed:
method DataArray.shift(shifts: Mapping[Any, int] | None=…, fill_value: Any=…, **shifts_kwargs: int) -> T_DataArray → method DataArray.shift(shifts: Mapping[Any, int] | None=…, fill_value: Any=…, **shifts_kwargs: int) -> Self - changed:
method DataArray.sortby(variables: Hashable | DataArray | Sequence[Hashable | DataArray], ascending: bool=…) -> DataArray → method DataArray.sortby(variables: Hashable | DataArray | Sequence[Hashable | DataArray] | Callable[[Self], Hashable | DataArray | Sequence[Hashable | DataArray]], ascending: bool=…) -> Self - changed:
method DataArray.stack(dimensions: Mapping[Any, Sequence[Hashable]] | None=…, create_index: bool | None=…, index_cls: type[Index]=…, **dimensions_kwargs: Sequence[Hashable]) -> T_DataArray → method DataArray.stack(dimensions: Mapping[Any, Sequence[Hashable]] | None=…, create_index: bool | None=…, index_cls: type[Index]=…, **dimensions_kwargs: Sequence[Hashable]) -> Self - changed:
method DataArray.swap_dims(dims_dict: Mapping[Any, Hashable] | None=…, **dims_kwargs) -> T_DataArray → method DataArray.swap_dims(dims_dict: Mapping[Any, Hashable] | None=…, **dims_kwargs) -> Self - changed:
method DataArray.tail(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> T_DataArray → method DataArray.tail(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> Self - changed:
method DataArray.thin(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> T_DataArray → method DataArray.thin(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> Self - changed:
method DataArray.to_dict(data: bool=…, encoding: bool=…) -> dict[str, Any] → method DataArray.to_dict(data: bool | Literal['list', 'array']=…, encoding: bool=…) -> dict[str, Any] - changed:
method DataArray.to_pandas() -> DataArray | pd.Series | pd.DataFrame → method DataArray.to_pandas() -> Self | pd.Series | pd.DataFrame - changed:
method DataArray.transpose(*dims: Hashable, transpose_coords: bool=…, missing_dims: ErrorOptionsWithWarn=…) -> T_DataArray → method DataArray.transpose(*dims: Hashable, transpose_coords: bool=…, missing_dims: ErrorOptionsWithWarn=…) -> Self - changed:
method DataArray.unify_chunks() -> DataArray → method DataArray.unify_chunks() -> Self - changed:
method DataArray.unstack(dim: Dims=…, fill_value: Any=…, sparse: bool=…) -> DataArray → method DataArray.unstack(dim: Dims=…, *, fill_value: Any=…, sparse: bool=…) -> Self - changed:
static method DataArray.from_dict(d: Mapping[str, Any]) -> T_DataArray → static method DataArray.from_dict(d: Mapping[str, Any]) -> Self - changed:
static method DataArray.from_iris(cube: iris_Cube) -> DataArray → static method DataArray.from_iris(cube: iris_Cube) -> Self - added:
method DataArray.drop_encoding() -> Self - added:
method DataArray.reset_encoding() -> Self - added:
method DataArray.to_dask_dataframe(dim_order: Sequence[Hashable] | None=…, set_index: bool=…) -> DaskDataFrame - added:
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] | None=…, safe_chunks: bool=…, storage_options: dict… - added:
property DataArray.T -> Self - added:
property DataArray.imag -> Self - added:
property DataArray.real -> Self - added:
variable DaskDataFrame
- removed:
property Dataset.imag -> T_Dataset - removed:
property Dataset.loc -> _LocIndexer[T_Dataset] - removed:
property Dataset.real -> T_Dataset - changed:
constructor Dataset(data_vars: Mapping[Any, Any] | None=…, coords: Mapping[Any, Any] | None=…, attrs: Mapping[Any, Any] | None=…) -> None → constructor Dataset(data_vars: DataVars | None=…, coords: Mapping[Any, Any] | None=…, attrs: Mapping[Any, Any] | None=…) -> None - changed:
method Dataset.apply(func: Callable, keep_attrs: bool | None=…, args: Iterable[Any]=…, **kwargs: Any) -> T_Dataset → method Dataset.apply(func: Callable, keep_attrs: bool | None=…, args: Iterable[Any]=…, **kwargs: Any) -> Self - changed:
method Dataset.argmax(dim: Hashable | None=…, **kwargs) -> T_Dataset → method Dataset.argmax(dim: Hashable | None=…, **kwargs) -> Self - changed:
method Dataset.argmin(dim: Hashable | None=…, **kwargs) -> T_Dataset → method Dataset.argmin(dim: Hashable | None=…, **kwargs) -> Self - changed:
method Dataset.as_numpy() -> T_Dataset → method Dataset.as_numpy() -> Self - changed:
method Dataset.assign(variables: Mapping[Any, Any] | None=…, **variables_kwargs: Any) -> T_Dataset → method Dataset.assign(variables: Mapping[Any, Any] | None=…, **variables_kwargs: Any) -> Self - changed:
method Dataset.bfill(dim: Hashable, limit: int | None=…) -> T_Dataset → method Dataset.bfill(dim: Hashable, limit: int | None=…) -> Self - changed:
method Dataset.broadcast_equals(other: Dataset) -> bool → method Dataset.broadcast_equals(other: Self) -> bool - changed:
method Dataset.broadcast_like(other: Dataset | DataArray, exclude: Iterable[Hashable] | None=…) -> T_Dataset → method Dataset.broadcast_like(other: T_DataArrayOrSet, exclude: Iterable[Hashable] | None=…) -> Self - changed:
method Dataset.chunk(chunks: int | Literal['auto'] | Mapping[Any, None | int | str | tuple[int, ...]]=…, name_prefix: str=…, token: str | None=…, lock: bool=…, inline_array: bool=…, **chunks_kwargs: None | int | str | tuple[int, ...]) -> T_Dataset → method Dataset.chunk(chunks: T_Chunks=…, name_prefix: str=…, token: str | None=…, lock: bool=…, inline_array: bool=…, chunked_array_type: str | ChunkManagerEntrypoint | None=…, from_array_kwargs=…, **chunks_kwargs: T_ChunkDim) -> Self - changed:
method Dataset.combine_first(other: T_Dataset) -> T_Dataset → method Dataset.combine_first(other: Self) -> Self - changed:
method Dataset.compute(**kwargs) -> T_Dataset → method Dataset.compute(**kwargs) -> Self - changed:
method Dataset.convert_calendar(calendar: CFCalendar, dim: Hashable=…, align_on: Literal['date', 'year', None]=…, missing: Any | None=…, use_cftime: bool | None=…) -> T_Dataset → 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.copy(deep: bool=…, data: Mapping[Any, ArrayLike] | None=…) -> T_Dataset → method Dataset.copy(deep: bool=…, data: DataVars | None=…) -> Self - changed:
method Dataset.cumulative_integrate(coord: Hashable | Sequence[Hashable], datetime_unit: DatetimeUnitOptions=…) -> T_Dataset → method Dataset.cumulative_integrate(coord: Hashable | Sequence[Hashable], datetime_unit: DatetimeUnitOptions=…) -> Self - changed:
method Dataset.curvefit(coords: str | DataArray | Iterable[str | DataArray], func: Callable[..., Any], reduce_dims: Dims=…, skipna: bool=…, p0: dict[str, Any] | None=…, bounds: dict[str, Any] | None=…, param_names: Sequence[str] | None=…, kwargs: dict[str, Any] | None=…) -> T_Dataset → method Dataset.curvefit(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=…) -> Self - changed:
method Dataset.diff(dim: Hashable, n: int=…, label: Literal['upper', 'lower']=…) -> T_Dataset → method Dataset.diff(dim: Hashable, n: int=…, *, label: Literal['upper', 'lower']=…) -> Self - changed:
method Dataset.differentiate(coord: Hashable, edge_order: Literal[1, 2]=…, datetime_unit: DatetimeUnitOptions | None=…) -> T_Dataset → method Dataset.differentiate(coord: Hashable, edge_order: Literal[1, 2]=…, datetime_unit: DatetimeUnitOptions | None=…) -> Self - changed:
method Dataset.drop(labels=…, dim=…, *, errors: ErrorOptions=…, **labels_kwargs) -> T_Dataset → method Dataset.drop(labels=…, dim=…, *, errors: ErrorOptions=…, **labels_kwargs) -> Self - changed:
method Dataset.drop_dims(drop_dims: str | Iterable[Hashable], *, errors: ErrorOptions=…) -> T_Dataset → method Dataset.drop_dims(drop_dims: str | Iterable[Hashable], *, errors: ErrorOptions=…) -> Self - changed:
method Dataset.drop_duplicates(dim: Hashable | Iterable[Hashable], keep: Literal['first', 'last', False]=…) -> T_Dataset → method Dataset.drop_duplicates(dim: Hashable | Iterable[Hashable], *, keep: Literal['first', 'last', False]=…) -> Self - changed:
method Dataset.drop_indexes(coord_names: Hashable | Iterable[Hashable], *, errors: ErrorOptions=…) -> T_Dataset → method Dataset.drop_indexes(coord_names: Hashable | Iterable[Hashable], *, errors: ErrorOptions=…) -> Self - changed:
method Dataset.drop_isel(indexers=…, **indexers_kwargs) -> T_Dataset → method Dataset.drop_isel(indexers=…, **indexers_kwargs) -> Self - changed:
method Dataset.drop_sel(labels=…, *, errors: ErrorOptions=…, **labels_kwargs) -> T_Dataset → method Dataset.drop_sel(labels=…, *, errors: ErrorOptions=…, **labels_kwargs) -> Self - changed:
method Dataset.drop_vars(names: Hashable | Iterable[Hashable], *, errors: ErrorOptions=…) -> T_Dataset → method Dataset.drop_vars(names: str | Iterable[Hashable] | Callable[[Self], str | Iterable[Hashable]], *, errors: ErrorOptions=…) -> Self - changed:
method Dataset.dropna(dim: Hashable, how: Literal['any', 'all']=…, thresh: int | None=…, subset: Iterable[Hashable] | None=…) -> T_Dataset → method Dataset.dropna(dim: Hashable, *, how: Literal['any', 'all']=…, thresh: int | None=…, subset: Iterable[Hashable] | None=…) -> Self - changed:
method Dataset.equals(other: Dataset) -> bool → method Dataset.equals(other: Self) -> bool - changed:
method Dataset.expand_dims(dim: None | Hashable | Sequence[Hashable] | Mapping[Any, Any]=…, axis: None | int | Sequence[int]=…, **dim_kwargs: Any) -> Dataset → method Dataset.expand_dims(dim: None | Hashable | Sequence[Hashable] | Mapping[Any, Any]=…, axis: None | int | Sequence[int]=…, **dim_kwargs: Any) -> Self - changed:
method Dataset.ffill(dim: Hashable, limit: int | None=…) -> T_Dataset → method Dataset.ffill(dim: Hashable, limit: int | None=…) -> Self - changed:
method Dataset.fillna(value: Any) -> T_Dataset → method Dataset.fillna(value: Any) -> Self - changed:
method Dataset.filter_by_attrs(**kwargs) -> T_Dataset → method Dataset.filter_by_attrs(**kwargs) -> Self - changed:
method Dataset.head(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> T_Dataset → method Dataset.head(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> Self - changed:
method Dataset.identical(other: Dataset) -> bool → method Dataset.identical(other: Self) -> bool - changed:
method Dataset.idxmax(dim: Hashable | None=…, skipna: bool | None=…, fill_value: Any=…, keep_attrs: bool | None=…) -> T_Dataset → method Dataset.idxmax(dim: Hashable | None=…, *, skipna: bool | None=…, fill_value: Any=…, keep_attrs: bool | None=…) -> Self - changed:
method Dataset.idxmin(dim: Hashable | None=…, skipna: bool | None=…, fill_value: Any=…, keep_attrs: bool | None=…) -> T_Dataset → method Dataset.idxmin(dim: Hashable | None=…, *, skipna: bool | None=…, fill_value: Any=…, keep_attrs: bool | None=…) -> Self - changed:
method Dataset.integrate(coord: Hashable | Sequence[Hashable], datetime_unit: DatetimeUnitOptions=…) -> T_Dataset → method Dataset.integrate(coord: Hashable | Sequence[Hashable], datetime_unit: DatetimeUnitOptions=…) -> Self - changed:
method Dataset.interp(coords: Mapping[Any, Any] | None=…, method: InterpOptions=…, assume_sorted: bool=…, kwargs: Mapping[str, Any] | None=…, method_non_numeric: str=…, **coords_kwargs: Any) -> T_Dataset → method Dataset.interp(coords: Mapping[Any, Any] | None=…, method: InterpOptions=…, assume_sorted: bool=…, kwargs: Mapping[str, Any] | None=…, method_non_numeric: str=…, **coords_kwargs: Any) -> Self - changed:
method Dataset.interp_calendar(target: pd.DatetimeIndex | CFTimeIndex | DataArray, dim: Hashable=…) -> T_Dataset → method Dataset.interp_calendar(target: pd.DatetimeIndex | CFTimeIndex | DataArray, dim: Hashable=…) -> Self - changed:
method Dataset.interp_like(other: Dataset | DataArray, method: InterpOptions=…, assume_sorted: bool=…, kwargs: Mapping[str, Any] | None=…, method_non_numeric: str=…) -> Dataset → method Dataset.interp_like(other: T_Xarray, method: InterpOptions=…, assume_sorted: bool=…, kwargs: Mapping[str, Any] | None=…, method_non_numeric: str=…) -> Self - changed:
method Dataset.interpolate_na(dim: Hashable | None=…, method: InterpOptions=…, limit: int | None=…, use_coordinate: bool | Hashable=…, max_gap: int | float | str | pd.Timedelta | np.timedelta64 | datetime.timedelta=…, **kwargs: Any) -> T_Dataset → method Dataset.interpolate_na(dim: Hashable | None=…, method: InterpOptions=…, limit: int | None=…, use_coordinate: bool | Hashable=…, max_gap: int | float | str | pd.Timedelta | np.timedelta64 | datetime.timedelta=…, **kwargs: Any) -> Self - changed:
method Dataset.isel(indexers: Mapping[Any, Any] | None=…, drop: bool=…, missing_dims: ErrorOptionsWithWarn=…, **indexers_kwargs: Any) -> T_Dataset → method Dataset.isel(indexers: Mapping[Any, Any] | None=…, drop: bool=…, missing_dims: ErrorOptionsWithWarn=…, **indexers_kwargs: Any) -> Self - changed:
method Dataset.load(**kwargs) -> T_Dataset → method Dataset.load(**kwargs) -> Self - changed:
method Dataset.map(func: Callable, keep_attrs: bool | None=…, args: Iterable[Any]=…, **kwargs: Any) -> T_Dataset → method Dataset.map(func: Callable, keep_attrs: bool | None=…, args: Iterable[Any]=…, **kwargs: Any) -> Self - changed:
method Dataset.merge(other: CoercibleMapping | DataArray, overwrite_vars: Hashable | Iterable[Hashable]=…, compat: CompatOptions=…, join: JoinOptions=…, fill_value: Any=…, combine_attrs: CombineAttrsOptions=…) -> T_Dataset → method Dataset.merge(other: CoercibleMapping | DataArray, overwrite_vars: Hashable | Iterable[Hashable]=…, compat: CompatOptions=…, join: JoinOptions=…, fill_value: Any=…, combine_attrs: CombineAttrsOptions=…) -> Self - changed:
method Dataset.pad(pad_width: Mapping[Any, int | tuple[int, int]] | None=…, mode: PadModeOptions=…, stat_length: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, constant_values: float | tuple[float, float] | Mapping[Any, tuple[float, float]] | None=…, end_values: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, reflect_type: PadReflectOptions=…, **pad_width_kwargs:… → method Dataset.pad(pad_width: Mapping[Any, int | tuple[int, int]] | None=…, mode: PadModeOptions=…, stat_length: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, constant_values: float | tuple[float, float] | Mapping[Any, tuple[float, float]] | None=…, end_values: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, reflect_type: PadReflectOptions=…, keep_attrs: bool | N… - changed:
method Dataset.persist(**kwargs) -> T_Dataset → method Dataset.persist(**kwargs) -> Self - changed:
method Dataset.polyfit(dim: Hashable, deg: int, skipna: bool | None=…, rcond: float | None=…, w: Hashable | Any=…, full: bool=…, cov: bool | Literal['unscaled']=…) -> T_Dataset → method Dataset.polyfit(dim: Hashable, deg: int, skipna: bool | None=…, rcond: float | None=…, w: Hashable | Any=…, full: bool=…, cov: bool | Literal['unscaled']=…) -> Self - changed:
method Dataset.quantile(q: ArrayLike, dim: Dims=…, method: QuantileMethods=…, numeric_only: bool=…, keep_attrs: bool | None=…, skipna: bool | None=…, interpolation: QuantileMethods | None=…) -> T_Dataset → method Dataset.quantile(q: ArrayLike, dim: Dims=…, *, method: QuantileMethods=…, numeric_only: bool=…, keep_attrs: bool | None=…, skipna: bool | None=…, interpolation: QuantileMethods | None=…) -> Self - changed:
method Dataset.query(queries: Mapping[Any, Any] | None=…, parser: QueryParserOptions=…, engine: QueryEngineOptions=…, missing_dims: ErrorOptionsWithWarn=…, **queries_kwargs: Any) -> T_Dataset → method Dataset.query(queries: Mapping[Any, Any] | None=…, parser: QueryParserOptions=…, engine: QueryEngineOptions=…, missing_dims: ErrorOptionsWithWarn=…, **queries_kwargs: Any) -> Self - changed:
method Dataset.rank(dim: Hashable, pct: bool=…, keep_attrs: bool | None=…) -> T_Dataset → method Dataset.rank(dim: Hashable, *, pct: bool=…, keep_attrs: bool | None=…) -> Self - changed:
method Dataset.reduce(func: Callable, dim: Dims=…, *, keep_attrs: bool | None=…, keepdims: bool=…, numeric_only: bool=…, **kwargs: Any) -> T_Dataset → method Dataset.reduce(func: Callable, dim: Dims=…, *, keep_attrs: bool | None=…, keepdims: bool=…, numeric_only: bool=…, **kwargs: Any) -> Self - changed:
method Dataset.reindex(indexers: Mapping[Any, Any] | None=…, method: ReindexMethodOptions=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value: Any=…, **indexers_kwargs: Any) -> T_Dataset → method Dataset.reindex(indexers: Mapping[Any, Any] | None=…, method: ReindexMethodOptions=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value: Any=…, **indexers_kwargs: Any) -> Self - changed:
method Dataset.reindex_like(other: Dataset | DataArray, method: ReindexMethodOptions=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value: Any=…) -> T_Dataset → method Dataset.reindex_like(other: T_Xarray, method: ReindexMethodOptions=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value: Any=…) -> Self - changed:
method Dataset.rename(name_dict: Mapping[Any, Hashable] | None=…, **names: Hashable) -> T_Dataset → method Dataset.rename(name_dict: Mapping[Any, Hashable] | None=…, **names: Hashable) -> Self - changed:
method Dataset.rename_dims(dims_dict: Mapping[Any, Hashable] | None=…, **dims: Hashable) -> T_Dataset → method Dataset.rename_dims(dims_dict: Mapping[Any, Hashable] | None=…, **dims: Hashable) -> Self - changed:
method Dataset.rename_vars(name_dict: Mapping[Any, Hashable] | None=…, **names: Hashable) -> T_Dataset → method Dataset.rename_vars(name_dict: Mapping[Any, Hashable] | None=…, **names: Hashable) -> Self - changed:
method Dataset.reorder_levels(dim_order: Mapping[Any, Sequence[int | Hashable]] | None=…, **dim_order_kwargs: Sequence[int | Hashable]) -> T_Dataset → method Dataset.reorder_levels(dim_order: Mapping[Any, Sequence[int | Hashable]] | None=…, **dim_order_kwargs: Sequence[int | Hashable]) -> Self - changed:
method Dataset.resample(indexer: Mapping[Any, str] | None=…, skipna: bool | None=…, closed: SideOptions | None=…, label: SideOptions | None=…, base: int | None=…, offset: pd.Timedelta | datetime.timedelta | str | None=…, origin: str | DatetimeLike=…, keep_attrs: bool | None=…, loffset: datetime.timedelta | str | None=…, restore_coord_dims: bool | None=…, **indexer_kwargs: str) -> DatasetResample → method Dataset.resample(indexer: Mapping[Any, str] | None=…, skipna: bool | None=…, closed: SideOptions | None=…, label: SideOptions | None=…, base: int | None=…, offset: pd.Timedelta | datetime.timedelta | str | None=…, origin: str | DatetimeLike=…, loffset: datetime.timedelta | str | None=…, restore_coord_dims: bool | None=…, **indexer_kwargs: str) -> DatasetResample - changed:
method Dataset.reset_coords(names: Dims=…, drop: bool=…) -> T_Dataset → method Dataset.reset_coords(names: Dims=…, drop: bool=…) -> Self - changed:
method Dataset.reset_index(dims_or_levels: Hashable | Sequence[Hashable], drop: bool=…) -> T_Dataset → method Dataset.reset_index(dims_or_levels: Hashable | Sequence[Hashable], *, drop: bool=…) -> Self - changed:
method Dataset.roll(shifts: Mapping[Any, int] | None=…, roll_coords: bool=…, **shifts_kwargs: int) -> T_Dataset → method Dataset.roll(shifts: Mapping[Any, int] | None=…, roll_coords: bool=…, **shifts_kwargs: int) -> Self - changed:
method Dataset.sel(indexers: Mapping[Any, Any] | None=…, method: str | None=…, tolerance: int | float | Iterable[int | float] | None=…, drop: bool=…, **indexers_kwargs: Any) -> T_Dataset → method Dataset.sel(indexers: Mapping[Any, Any] | None=…, method: str | None=…, tolerance: int | float | Iterable[int | float] | None=…, drop: bool=…, **indexers_kwargs: Any) -> Self - changed:
method Dataset.set_coords(names: Hashable | Iterable[Hashable]) -> T_Dataset → method Dataset.set_coords(names: Hashable | Iterable[Hashable]) -> Self - changed:
method Dataset.set_index(indexes: Mapping[Any, Hashable | Sequence[Hashable]] | None=…, append: bool=…, **indexes_kwargs: Hashable | Sequence[Hashable]) -> Dataset → method Dataset.set_index(indexes: Mapping[Any, Hashable | Sequence[Hashable]] | None=…, append: bool=…, **indexes_kwargs: Hashable | Sequence[Hashable]) -> Self - changed:
method Dataset.set_xindex(coord_names: str | Sequence[Hashable], index_cls: type[Index] | None=…, **options) -> T_Dataset → method Dataset.set_xindex(coord_names: str | Sequence[Hashable], index_cls: type[Index] | None=…, **options) -> Self - changed:
method Dataset.shift(shifts: Mapping[Any, int] | None=…, fill_value: Any=…, **shifts_kwargs: int) -> T_Dataset → method Dataset.shift(shifts: Mapping[Any, int] | None=…, fill_value: Any=…, **shifts_kwargs: int) -> Self - changed:
method Dataset.sortby(variables: Hashable | DataArray | list[Hashable | DataArray], ascending: bool=…) -> T_Dataset → method Dataset.sortby(variables: Hashable | DataArray | Sequence[Hashable | DataArray] | Callable[[Self], Hashable | DataArray | list[Hashable | DataArray]], ascending: bool=…) -> Self - changed:
method Dataset.stack(dimensions: Mapping[Any, Sequence[Hashable | ellipsis]] | None=…, create_index: bool | None=…, index_cls: type[Index]=…, **dimensions_kwargs: Sequence[Hashable | ellipsis]) -> T_Dataset → method Dataset.stack(dimensions: Mapping[Any, Sequence[Hashable | ellipsis]] | None=…, create_index: bool | None=…, index_cls: type[Index]=…, **dimensions_kwargs: Sequence[Hashable | ellipsis]) -> Self - changed:
method Dataset.swap_dims(dims_dict: Mapping[Any, Hashable] | None=…, **dims_kwargs) -> T_Dataset → method Dataset.swap_dims(dims_dict: Mapping[Any, Hashable] | None=…, **dims_kwargs) -> Self - changed:
method Dataset.tail(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> T_Dataset → method Dataset.tail(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> Self - changed:
method Dataset.thin(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> T_Dataset → method Dataset.thin(indexers: Mapping[Any, int] | int | None=…, **indexers_kwargs: Any) -> Self - changed:
method Dataset.to_dict(data: bool=…, encoding: bool=…) -> dict[str, Any] → method Dataset.to_dict(data: bool | Literal['list', 'array']=…, encoding: bool=…) -> dict[str, Any] - changed:
method Dataset.to_zarr(store: MutableMapping | str | PathLike[str] | None=…, chunk_store: MutableMapping | str | PathLike | None=…, mode: Literal['w', 'w-', 'a', 'r+', None]=…, synchronizer=…, group: str | None=…, encoding: Mapping | None=…, compute: Literal[True]=…, consolidated: bool | None=…, append_dim: Hashable | None=…, region: Mapping[str, slice] | None=…, safe_chunks: bool=…, storage_opti… → 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… - changed:
method Dataset.transpose(*dims: Hashable, missing_dims: ErrorOptionsWithWarn=…) -> T_Dataset → method Dataset.transpose(*dims: Hashable, missing_dims: ErrorOptionsWithWarn=…) -> Self - changed:
method Dataset.unify_chunks() -> T_Dataset → method Dataset.unify_chunks() -> Self - changed:
method Dataset.unstack(dim: Dims=…, fill_value: Any=…, sparse: bool=…) -> T_Dataset → method Dataset.unstack(dim: Dims=…, *, fill_value: Any=…, sparse: bool=…) -> Self - changed:
method Dataset.update(other: CoercibleMapping) -> T_Dataset → method Dataset.update(other: CoercibleMapping) -> Self - changed:
static method Dataset.from_dataframe(dataframe: pd.DataFrame, sparse: bool=…) -> T_Dataset → static method Dataset.from_dataframe(dataframe: pd.DataFrame, sparse: bool=…) -> Self - changed:
static method Dataset.from_dict(d: Mapping[Any, Any]) -> T_Dataset → static method Dataset.from_dict(d: Mapping[Any, Any]) -> Self - changed:
static method Dataset.load_store(store, decoder=…) -> T_Dataset → static method Dataset.load_store(store, decoder=…) -> Self - added:
function merge_data_and_coords(data_vars: DataVars, coords) -> _MergeResult - added:
method Dataset.drop_encoding() -> Self - added:
method Dataset.eval(statement: str, *, parser: QueryParserOptions=…) -> Self | T_DataArray - added:
method Dataset.reset_encoding() -> Self - added:
method Dataset.to_dataarray(dim: Hashable=…, name: Hashable | None=…) -> DataArray - added:
property Dataset.imag -> Self - added:
property Dataset.loc -> _LocIndexer[Self] - added:
property Dataset.real -> Self
- changed:
function maybe_promote(dtype) → function maybe_promote(dtype: np.dtype) -> tuple[np.dtype, Any] - changed:
function result_type(*arrays_and_dtypes) → function result_type(*arrays_and_dtypes: np.typing.ArrayLike | np.typing.DTypeLike) -> np.dtype - changed:
variable PROMOTE_TO_OBJECT → variable PROMOTE_TO_OBJECT: tuple[tuple[type[np.generic], type[np.generic]], ...]
- added:
function broadcast_to(array, shape) - added:
function chunked_nanfirst(darray, axis) - added:
function chunked_nanlast(darray, axis) - added:
function einsum(*args, **kwargs) - added:
function ravel(array)
- removed:
function nondefault_indexes(indexes) - removed:
function short_numpy_repr(array) - changed:
function coords_repr(coords, col_width=…, max_rows=…) → function coords_repr(coords: AbstractCoordinates, col_width=…, max_rows=…) - changed:
function indexes_repr(indexes, col_width=…, max_rows=…) → function indexes_repr(indexes, max_rows: int | None=…) -> str - changed:
function inline_index_repr(index, max_width=…) → function inline_index_repr(index: pd.Index, max_width=…) - changed:
function summarize_index(name: Hashable, index, col_width: int, max_width: int | None=…) → function summarize_index(names: tuple[Hashable, ...], index, col_width: int, max_width: int | None=…) -> str - added:
function filter_nondefault_indexes(indexes, filter_indexes: bool) - added:
function short_array_repr(array) - added:
function shorten_list_repr(items: Sequence, max_items: int) -> str
- changed:
function array_repr(arr) → function array_repr(arr) -> str - changed:
function array_section(obj) → function array_section(obj) -> str - changed:
function collapsible_section(name, inline_details=…, details=…, n_items=…, enabled=…, collapsed=…) → function collapsible_section(name, inline_details=…, details=…, n_items=…, enabled=…, collapsed=…) -> str - changed:
function dataset_repr(ds) → function dataset_repr(ds) -> str - changed:
function dim_section(obj) → function dim_section(obj) -> str - changed:
function format_dims(dims, dims_with_index) → function format_dims(dim_sizes, dims_with_index) -> str - changed:
function short_data_repr_html(array) → function short_data_repr_html(array) -> str - changed:
function short_index_repr_html(index) → function short_index_repr_html(index) -> str - changed:
function summarize_attrs(attrs) → function summarize_attrs(attrs) -> str - changed:
function summarize_coords(variables) → function summarize_coords(variables) -> str - changed:
function summarize_index(coord_names, index) → function summarize_index(coord_names, index) -> str - changed:
function summarize_indexes(indexes) → function summarize_indexes(indexes) -> str - changed:
function summarize_variable(name, var, is_index=…, dtype=…) → function summarize_variable(name, var, is_index=…, dtype=…) -> str - changed:
function summarize_vars(variables) → function summarize_vars(variables) -> str
- removed:
property GroupBy.groups -> dict[GroupKey, slice | int | list[int]] - removed:
property GroupBy.sizes -> Frozen[Hashable, int] - changed:
constructor GroupBy(obj: T_Xarray, group: Hashable | DataArray | IndexVariable, squeeze: bool=…, grouper: pd.Grouper | None=…, bins: ArrayLike | None=…, restore_coord_dims: bool=…, cut_kwargs: Mapping[Any, Any] | None=…) -> None → constructor GroupBy(obj: T_Xarray, groupers: tuple[ResolvedGrouper], squeeze: bool=…, restore_coord_dims: bool=…) -> None - changed:
function unique_value_groups(ar, sort: bool=…) -> tuple[np.ndarray | pd.Index, list[list[int]]] → function unique_value_groups(ar, sort: bool=…) -> tuple[np.ndarray | pd.Index, T_GroupIndices, np.ndarray] - changed:
method GroupBy.quantile(q: ArrayLike, dim: Dims=…, method: QuantileMethods=…, keep_attrs: bool | None=…, skipna: bool | None=…, interpolation: QuantileMethods | None=…) -> T_Xarray → method GroupBy.quantile(q: ArrayLike, dim: Dims=…, *, method: QuantileMethods=…, keep_attrs: bool | None=…, skipna: bool | None=…, interpolation: QuantileMethods | None=…) -> T_Xarray - added:
class BinGrouper(Grouper) - added:
class Grouper(ABC) - added:
class ResolvedBinGrouper(ResolvedGrouper) - added:
class ResolvedGrouper(ABC, Generic[T_Xarray]) - added:
class ResolvedTimeResampleGrouper(ResolvedGrouper) - added:
class ResolvedUniqueGrouper(ResolvedGrouper) - added:
class TimeResampleGrouper(Grouper) - added:
class UniqueGrouper(Grouper) - added:
field BinGrouper.bins: Any - added:
field BinGrouper.cut_kwargs: Mapping - added:
field GroupBy.groupers: tuple[ResolvedGrouper] - added:
field ResolvedBinGrouper.grouper: BinGrouper - added:
field ResolvedGrouper.codes: DataArray - added:
field ResolvedGrouper.full_index: pd.Index - added:
field ResolvedGrouper.group1d: T_Group - added:
field ResolvedGrouper.group: T_Group - added:
field ResolvedGrouper.group_indices: T_GroupIndices - added:
field ResolvedGrouper.grouper: Grouper - added:
field ResolvedGrouper.inserted_dims: list[Hashable] - added:
field ResolvedGrouper.obj: T_Xarray - added:
field ResolvedGrouper.stacked_dim: Hashable | None - added:
field ResolvedGrouper.stacked_obj: T_Xarray - added:
field ResolvedGrouper.unique_coord: IndexVariable | _DummyGroup - added:
field ResolvedTimeResampleGrouper.grouper: TimeResampleGrouper - added:
field ResolvedTimeResampleGrouper.index_grouper: CFTimeGrouper | pd.Grouper - added:
field ResolvedUniqueGrouper.grouper: UniqueGrouper - added:
field TimeResampleGrouper.closed: SideOptions | None - added:
field TimeResampleGrouper.freq: str - added:
field TimeResampleGrouper.label: SideOptions | None - added:
field TimeResampleGrouper.loffset: datetime.timedelta | str | None - added:
field TimeResampleGrouper.offset: pd.Timedelta | datetime.timedelta | str | None - added:
field TimeResampleGrouper.origin: str | DatetimeLike | None - added:
method ResolvedGrouper.factorize(squeeze: bool) -> None - added:
method ResolvedTimeResampleGrouper.first_items() -> tuple[pd.Series, np.ndarray] - added:
property GroupBy.groups -> dict[GroupKey, GroupIndex] - added:
property GroupBy.sizes -> Mapping[Hashable, int] - added:
property ResolvedGrouper.dims - added:
property ResolvedGrouper.group_as_index -> pd.Index - added:
property ResolvedGrouper.is_unique_and_monotonic -> bool - added:
property ResolvedGrouper.name -> Hashable - added:
property ResolvedGrouper.size -> int - added:
variable GroupIndex - added:
variable T_FactorizeOut - added:
variable T_GroupIndices
- changed:
constructor Indexes(indexes: dict[Any, T_PandasOrXarrayIndex], variables: dict[Any, Variable]) → constructor Indexes(indexes: Mapping[Any, T_PandasOrXarrayIndex] | None=…, variables: Mapping[Any, Variable] | None=…, index_type: type[Index] | type[pd.Index]=…) - changed:
method Index.copy(deep: bool=…) -> T_Index → method Index.copy(deep: bool=…) -> Self - changed:
method Index.equals(other) → method Index.equals(other: Self) -> bool - changed:
method Index.isel(indexers: Mapping[Any, int | slice | np.ndarray | Variable]) -> Index | None → method Index.isel(indexers: Mapping[Any, int | slice | np.ndarray | Variable]) -> Self | None - changed:
method Index.join(other: T_Index, how: str=…) -> T_Index → method Index.join(other: Self, how: JoinOptions=…) -> Self - changed:
method Index.reindex_like(other: T_Index) -> dict[Hashable, Any] → method Index.reindex_like(other: Self) -> dict[Hashable, Any] - changed:
method Index.rename(name_dict: Mapping[Any, Hashable], dims_dict: Mapping[Any, Hashable]) -> Index → method Index.rename(name_dict: Mapping[Any, Hashable], dims_dict: Mapping[Any, Hashable]) -> Self - changed:
method Index.roll(shifts: Mapping[Any, int]) -> Index | None → method Index.roll(shifts: Mapping[Any, int]) -> Self | None - changed:
method Indexes.copy_indexes(deep: bool=…, memo: dict[int, Any] | None=…) -> tuple[dict[Hashable, T_PandasOrXarrayIndex], dict[Hashable, Variable]] → method Indexes.copy_indexes(deep: bool=…, memo: dict[int, T_PandasOrXarrayIndex] | None=…) -> tuple[dict[Hashable, T_PandasOrXarrayIndex], dict[Hashable, Variable]] - changed:
method PandasIndex.join(other: PandasIndex, how: str=…) -> PandasIndex → method PandasIndex.join(other: Self, how: str=…) -> Self - changed:
method PandasIndex.reindex_like(other: PandasIndex, method=…, tolerance=…) -> dict[Hashable, Any] → method PandasIndex.reindex_like(other: Self, method=…, tolerance=…) -> dict[Hashable, Any] - changed:
static method Index.concat(indexes: Sequence[T_Index], dim: Hashable, positions: Iterable[Iterable[int]] | None=…) -> T_Index → static method Index.concat(indexes: Sequence[Self], dim: Hashable, positions: Iterable[Iterable[int]] | None=…) -> Self - changed:
static method Index.from_variables(variables: Mapping[Any, Variable], *, options: Mapping[str, Any]) -> Index → static method Index.from_variables(variables: Mapping[Any, Variable], *, options: Mapping[str, Any]) -> Self - changed:
static method Index.stack(variables: Mapping[Any, Variable], dim: Hashable) -> Index → static method Index.stack(variables: Mapping[Any, Variable], dim: Hashable) -> Self - changed:
static method PandasIndex.concat(indexes: Sequence[PandasIndex], dim: Hashable, positions: Iterable[Iterable[int]] | None=…) -> PandasIndex → static method PandasIndex.concat(indexes: Sequence[Self], dim: Hashable, positions: Iterable[Iterable[int]] | None=…) -> Self - changed:
static method PandasMultiIndex.concat(indexes: Sequence[PandasMultiIndex], dim: Hashable, positions: Iterable[Iterable[int]] | None=…) -> PandasMultiIndex → static method PandasMultiIndex.concat(indexes: Sequence[Self], dim: Hashable, positions: Iterable[Iterable[int]] | None=…) -> Self
- added:
method CopyOnWriteArray.get_duck_array() - added:
method ExplicitlyIndexed.get_duck_array() - added:
method ExplicitlyIndexedNDArrayMixin.get_duck_array() - added:
method ImplicitToExplicitIndexingAdapter.get_duck_array() - added:
method LazilyIndexedArray.get_duck_array() - added:
method LazilyVectorizedIndexedArray.get_duck_array() - added:
method MemoryCachedArray.get_duck_array() - added:
method PandasIndexingAdapter.get_duck_array() -> np.ndarray
- removed:
function merge_data_and_coords(data_vars, coords, compat=…, join=…) - changed:
function assert_valid_explicit_coords(variables, dims, explicit_coords) → function assert_valid_explicit_coords(variables: Mapping[Any, Any], dims: Mapping[Any, int], explicit_coords: Iterable[Hashable]) -> None - changed:
function collect_variables_and_indexes(list_of_mappings: list[DatasetLike], indexes: Mapping[Any, Any] | None=…) -> dict[Hashable, list[MergeElement]] → function collect_variables_and_indexes(list_of_mappings: Iterable[DatasetLike], indexes: Mapping[Any, Any] | None=…) -> dict[Hashable, list[MergeElement]] - changed:
function merge_collected(grouped: dict[Hashable, list[MergeElement]], prioritized: Mapping[Any, MergeElement] | None=…, compat: CompatOptions=…, combine_attrs: CombineAttrsOptions=…, equals: dict[Hashable, bool] | None=…) -> tuple[dict[Hashable, Variable], dict[Hashable, Index]] → 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]] - changed:
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]] → 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]] - changed:
function merge_core(objects: Iterable[CoercibleMapping], compat: CompatOptions=…, join: JoinOptions=…, combine_attrs: CombineAttrsOptions=…, priority_arg: int | None=…, explicit_coords: Sequence | None=…, indexes: Mapping[Any, Any] | None=…, fill_value: object=…) -> _MergeResult → 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
- changed:
function inverse_permutation(indices) → function inverse_permutation(indices: np.ndarray, N: int | None=…) -> np.ndarray - changed:
function nanfirst(values, axis) → function nanfirst(values, axis, keepdims=…) - changed:
function nanlast(values, axis) → function nanlast(values, axis, keepdims=…)
- removed:
class IncludeCumMethods - removed:
function inject_cum_methods(cls) - removed:
variable NAN_CUM_METHODS
- removed:
variable Colormap - added:
field T_Options.use_numbagg: bool - added:
field T_Options.use_opt_einsum: bool
- added:
class ChunkManagerEntrypoint(ABC, Generic[T_ChunkedArray]) - added:
constructor ChunkManagerEntrypoint() -> None - added:
field ChunkManagerEntrypoint.array_cls: type[T_ChunkedArray] - added:
field ChunkManagerEntrypoint.available: bool - added:
function get_chunked_array_type(*args) -> ChunkManagerEntrypoint - added:
function guess_chunkmanager(manager: str | ChunkManagerEntrypoint | None) -> ChunkManagerEntrypoint - added:
function list_chunkmanagers() -> dict[str, ChunkManagerEntrypoint] - added:
function load_chunkmanagers(entrypoints: Sequence[EntryPoint]) -> dict[str, ChunkManagerEntrypoint] - added:
method ChunkManagerEntrypoint.apply_gufunc(func: Callable, signature: str, *args: Any, axes: Sequence[tuple[int, ...]] | None=…, keepdims: bool=…, output_dtypes: Sequence[np.typing.DTypeLike] | None=…, vectorize: bool | None=…, **kwargs) - added:
method ChunkManagerEntrypoint.blockwise(func: Callable, out_ind: Iterable, *args: Any, adjust_chunks: dict[Any, Callable] | None=…, new_axes: dict[Any, int] | None=…, align_arrays: bool=…, **kwargs) - added:
method ChunkManagerEntrypoint.chunks(data: T_ChunkedArray) -> T_NormalizedChunks - added:
method ChunkManagerEntrypoint.compute(*data: T_ChunkedArray | Any, **kwargs) -> tuple[np.ndarray, ...] - added:
method ChunkManagerEntrypoint.from_array(data: T_DuckArray | np.typing.ArrayLike, chunks: T_Chunks, **kwargs) -> T_ChunkedArray - added:
method ChunkManagerEntrypoint.is_chunked_array(data: Any) -> bool - added:
method ChunkManagerEntrypoint.map_blocks(func: Callable, *args: Any, dtype: np.typing.DTypeLike | None=…, chunks: tuple[int, ...] | None=…, drop_axis: int | Sequence[int] | None=…, new_axis: int | Sequence[int] | None=…, **kwargs) - added:
method ChunkManagerEntrypoint.normalize_chunks(chunks: T_Chunks | T_NormalizedChunks, shape: tuple[int, ...] | None=…, limit: int | None=…, dtype: np.dtype | None=…, previous_chunks: T_NormalizedChunks | None=…) -> T_NormalizedChunks - added:
method ChunkManagerEntrypoint.rechunk(data: T_ChunkedArray, chunks: T_NormalizedChunks | tuple[int, ...] | T_Chunks, **kwargs) -> T_ChunkedArray - added:
method ChunkManagerEntrypoint.reduction(arr: T_ChunkedArray, func: Callable, combine_func: Callable | None=…, aggregate_func: Callable | None=…, axis: int | Sequence[int] | None=…, dtype: np.dtype | None=…, keepdims: bool=…) -> T_ChunkedArray - added:
method ChunkManagerEntrypoint.store(sources: T_ChunkedArray | Sequence[T_ChunkedArray], targets: Any, **kwargs: dict[str, Any]) - added:
method ChunkManagerEntrypoint.unify_chunks(*args: Any, **kwargs) -> tuple[dict[str, T_NormalizedChunks], list[T_ChunkedArray]] - added:
property ChunkManagerEntrypoint.array_api -> Any - added:
variable T_ChunkedArray
- added:
function nanosecond_precision_timestamp(*args, **kwargs) -> pd.Timestamp - added:
variable NoDefault - added:
variable no_default
- added:
function is_0d_dask_array(x) - added:
function is_chunked_array(x) -> bool - added:
function to_duck_array(data) - added:
function to_numpy(data) -> np.ndarray
- changed:
constructor CFTimeGrouper(freq: str | BaseCFTimeOffset, closed: SideOptions | None=…, label: SideOptions | None=…, base: int | None=…, loffset: str | datetime.timedelta | BaseCFTimeOffset | None=…, origin: str | CFTimeDatetime=…, offset: str | datetime.timedelta | None=…) → constructor CFTimeGrouper(freq: str | BaseCFTimeOffset, closed: SideOptions | None=…, label: SideOptions | None=…, loffset: str | datetime.timedelta | BaseCFTimeOffset | None=…, origin: str | CFTimeDatetime=…, offset: str | datetime.timedelta | None=…)
- added:
field Coarsen.boundary: CoarsenBoundaryOptions - added:
field Coarsen.coord_func: Mapping[Hashable, str | Callable] - added:
field Coarsen.side: SideOptions | Mapping[Hashable, SideOptions] - added:
field Coarsen.windows: Mapping[Hashable, int] - added:
field Rolling.center: list[bool] - added:
field Rolling.dim: list[Hashable] - added:
field Rolling.min_periods: int - added:
field Rolling.obj: T_Xarray - added:
field Rolling.window: list[int]
- removed:
function move_exp_nanmean(array, *, axis, alpha) - removed:
function move_exp_nansum(array, *, axis, alpha) - changed:
constructor RollingExp(obj: T_DataWithCoords, windows: Mapping[Any, int | float], window_type: str=…) → 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.std() -> T_DataWithCoords - added:
method RollingExp.var() -> T_DataWithCoords
- removed:
variable GroupByIncompatible - added:
class Alignable(Protocol) - added:
method Alignable.copy(deep: bool=…) -> Self - added:
property Alignable.dims -> Frozen[Hashable, int] | tuple[Hashable, ...] - added:
property Alignable.sizes -> Mapping[Hashable, int] - added:
property Alignable.xindexes -> Indexes[Index] - added:
variable CubedArray - added:
variable DataVars - added:
variable GroupByCompatible - added:
variable InclusiveOptions - added:
variable T_Alignable - added:
variable T_ChunkDim: TypeAlias - added:
variable T_Chunks: TypeAlias - added:
variable T_Coordinates - added:
variable T_DuckArray - added:
variable T_NormalizedChunks - added:
variable ZarrArray - added:
variable ZarrWriteModes
- removed:
function contains_only_dask_or_numpy(obj) -> bool - changed:
function is_duck_array(value: Any) -> bool → function is_duck_array(value: Any) -> TypeGuard[T_DuckArray] - added:
class FrozenMappingWarningOnValuesAccess(Frozen[K, V]) - added:
function consolidate_dask_from_array_kwargs(from_array_kwargs: dict, name: str | None=…, lock: bool | None=…, inline_array: bool | None=…) -> dict - added:
function contains_only_chunked_or_numpy(obj) -> bool - added:
method FrozenMappingWarningOnValuesAccess.get(key: K, /) -> V | None | (key: K, /, default: V | T) -> V | T - added:
method FrozenMappingWarningOnValuesAccess.items() -> ItemsView[K, V] - added:
method FrozenMappingWarningOnValuesAccess.keys() -> KeysView[K] - added:
method FrozenMappingWarningOnValuesAccess.values() -> ValuesView[V]
- removed:
method Variable.copy(deep: bool=…, data: ArrayLike | None=…) -> T_Variable - removed:
property Variable.T -> Variable - removed:
property Variable.attrs -> dict[Any, Any] - removed:
property Variable.chunks -> tuple[tuple[int, ...], ...] | None - removed:
property Variable.chunksizes -> Mapping[Any, tuple[int, ...]] - removed:
property Variable.data -> Any - removed:
property Variable.dims -> tuple[Hashable, ...] - removed:
property Variable.dtype - removed:
property Variable.imag - removed:
property Variable.nbytes -> int - removed:
property Variable.real - removed:
property Variable.shape - removed:
variable Coordinate - changed:
class Variable(AbstractArray, NdimSizeLenMixin, VariableArithmetic) → class Variable(NamedArray, AbstractArray, VariableArithmetic) - changed:
constructor Variable(dims, data, attrs=…, encoding=…, fastpath=…) → constructor Variable(dims, data: T_DuckArray | ArrayLike, attrs=…, encoding=…, fastpath=…) - changed:
function as_compatible_data(data, fastpath=…) → function as_compatible_data(data: T_DuckArray | ArrayLike, fastpath: bool=…) -> T_DuckArray - changed:
function as_variable(obj, name=…) -> Variable | IndexVariable → function as_variable(obj: T_DuckArray | Any, name=…) -> Variable | IndexVariable - changed:
method IndexVariable.chunk(chunks=…, name=…, lock=…, inline_array=…) → method IndexVariable.chunk(chunks=…, name=…, lock=…, inline_array=…, chunked_array_type=…, from_array_kwargs=…) - changed:
method IndexVariable.copy(deep: bool=…, data: ArrayLike | None=…) → method IndexVariable.copy(deep: bool=…, data: T_DuckArray | ArrayLike | None=…) - changed:
method Variable.as_numpy() -> T_Variable → method Variable.as_numpy() -> Self - changed:
method Variable.astype(dtype, *, order=…, casting=…, subok=…, copy=…, keep_attrs=…) -> T_Variable → method Variable.astype(dtype, *, order=…, casting=…, subok=…, copy=…, keep_attrs=…) -> Self - changed:
method Variable.chunk(chunks: int | Literal['auto'] | tuple[int, ...] | tuple[tuple[int, ...], ...] | Mapping[Any, None | int | tuple[int, ...]]=…, name: str | None=…, lock: bool=…, inline_array: bool=…, **chunks_kwargs: Any) -> Variable → method Variable.chunk(chunks: T_Chunks=…, name: str | None=…, lock: bool | None=…, inline_array: bool | None=…, chunked_array_type: str | ChunkManagerEntrypoint | None=…, from_array_kwargs=…, **chunks_kwargs: Any) -> Self - changed:
method Variable.isel(indexers: Mapping[Any, Any] | None=…, missing_dims: ErrorOptionsWithWarn=…, **indexers_kwargs: Any) -> T_Variable → method Variable.isel(indexers: Mapping[Any, Any] | None=…, missing_dims: ErrorOptionsWithWarn=…, **indexers_kwargs: Any) -> Self - changed:
method Variable.pad(pad_width: Mapping[Any, int | tuple[int, int]] | None=…, mode: PadModeOptions=…, stat_length: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, constant_values: float | tuple[float, float] | Mapping[Any, tuple[float, float]] | None=…, end_values: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, reflect_type: PadReflectOptions=…, **pad_width_kwargs:… → method Variable.pad(pad_width: Mapping[Any, int | tuple[int, int]] | None=…, mode: PadModeOptions=…, stat_length: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, constant_values: float | tuple[float, float] | Mapping[Any, tuple[float, float]] | None=…, end_values: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, reflect_type: PadReflectOptions=…, keep_attrs: bool |… - changed:
method Variable.quantile(q: ArrayLike, dim: str | Sequence[Hashable] | None=…, method: QuantileMethods=…, keep_attrs: bool | None=…, skipna: bool | None=…, interpolation: QuantileMethods | None=…) -> Variable → method Variable.quantile(q: ArrayLike, dim: str | Sequence[Hashable] | None=…, method: QuantileMethods=…, keep_attrs: bool | None=…, skipna: bool | None=…, interpolation: QuantileMethods | None=…) -> Self - changed:
method Variable.to_dict(data: bool=…, encoding: bool=…) -> dict → method Variable.to_dict(data: bool | str=…, encoding: bool=…) -> dict[str, Any] - changed:
method Variable.transpose(*dims: Hashable | ellipsis, missing_dims: ErrorOptionsWithWarn=…) -> Variable → method Variable.transpose(*dims: Hashable | ellipsis, missing_dims: ErrorOptionsWithWarn=…) -> Self - added:
method Variable.drop_encoding() -> Self - added:
method Variable.reset_encoding() -> Self - added:
property Variable.T -> Self - added:
property Variable.data - added:
property Variable.imag -> Variable - added:
property Variable.real -> Variable
- changed:
method Weighted.mean(dim: Dims=…, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray → method Weighted.mean(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray - changed:
method Weighted.std(dim: Dims=…, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray → method Weighted.std(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray - changed:
method Weighted.sum(dim: Dims=…, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray → method Weighted.sum(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray - changed:
method Weighted.sum_of_squares(dim: Dims=…, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray → method Weighted.sum_of_squares(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray - changed:
method Weighted.sum_of_weights(dim: Dims=…, keep_attrs: bool | None=…) -> T_Xarray → method Weighted.sum_of_weights(dim: Dims=…, *, keep_attrs: bool | None=…) -> T_Xarray - changed:
method Weighted.var(dim: Dims=…, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray → method Weighted.var(dim: Dims=…, *, skipna: bool | None=…, keep_attrs: bool | None=…) -> T_Xarray
- added:
class NamedArray(NamedArrayAggregations, Generic[_ShapeType_co, _DType_co]) - added:
constructor NamedArray(dims: _DimsLike, data: duckarray[Any, _DType_co], attrs: _AttrsLike=…) - added:
function from_array(dims: _DimsLike, data: duckarray[_ShapeType, _DType], attrs: _AttrsLike=…) -> NamedArray[_ShapeType, _DType] | (dims: _DimsLike, data: ArrayLike, attrs: _AttrsLike=…) -> NamedArray[Any, Any] - added:
method NamedArray.copy(deep: bool=…, data: duckarray[_ShapeType_co, _DType_co] | None=…) -> Self - added:
method NamedArray.get_axis_num(dim: Hashable | Iterable[Hashable]) -> int | tuple[int, ...] - added:
method NamedArray.reduce(func: Callable[..., Any], dim: Dims=…, axis: int | Sequence[int] | None=…, keepdims: bool=…, **kwargs: Any) -> NamedArray[Any, Any] - added:
property NamedArray.attrs -> dict[Any, Any] - added:
property NamedArray.chunks -> _Chunks | None - added:
property NamedArray.chunksizes -> Mapping[_Dim, _Shape] - added:
property NamedArray.data -> duckarray[Any, _DType_co] - added:
property NamedArray.dims -> _Dims - added:
property NamedArray.dtype -> _DType_co - added:
property NamedArray.imag -> NamedArray[_ShapeType, _dtype[_ScalarType]] - added:
property NamedArray.nbytes -> _IntOrUnknown - added:
property NamedArray.ndim -> int - added:
property NamedArray.real -> NamedArray[_ShapeType, _dtype[_ScalarType]] - added:
property NamedArray.shape -> _Shape - added:
property NamedArray.size -> _IntOrUnknown - added:
property NamedArray.sizes -> dict[_Dim, _IntOrUnknown] - added:
variable Graph: Any - added:
variable NestedKeys: Any - added:
variable PostComputeCallable: Any - added:
variable PostPersistCallable: Any - added:
variable SchedulerGetCallable: Any - added:
variable T_NamedArray - added:
variable T_NamedArrayInteger
- added:
class AlwaysGreaterThan - added:
class AlwaysLessThan - added:
function get_fill_value(dtype: np.dtype[np.generic]) -> Any - added:
function get_neg_infinity(dtype: np.dtype[np.generic], min_for_int: bool=…) -> float | complex | AlwaysLessThan - added:
function get_pos_infinity(dtype: np.dtype[np.generic], max_for_int: bool=…) -> float | complex | AlwaysGreaterThan - added:
function is_datetime_like(dtype: np.dtype[np.generic]) -> TypeGuard[np.datetime64 | np.timedelta64] - added:
function maybe_promote(dtype: np.dtype[np.generic]) -> tuple[np.dtype[np.generic], Any] - added:
function result_type(*arrays_and_dtypes: np.typing.ArrayLike | np.typing.DTypeLike) -> np.dtype[np.generic] - added:
variable INF - added:
variable NA - added:
variable NAT_TYPES - added:
variable NINF - added:
variable PROMOTE_TO_OBJECT: tuple[tuple[type[np.generic], type[np.generic]], ...]
- added:
class ReprObject - added:
constructor ReprObject(value: str) - added:
function is_dask_collection(x: object) -> TypeGuard[DaskCollection] - added:
function is_duck_dask_array(x: duckarray[Any, Any]) -> TypeGuard[DaskArray] - added:
function module_available(module: str) -> bool - added:
function to_0d_object_array(value: object) -> NDArray[np.object_] - added:
variable DaskArray - added:
variable DaskCollection: Any
- changed:
method DataArrayPlotAccessor.hist(*args, **kwargs) -> tuple[np.ndarray, np.ndarray, BarContainer] → method DataArrayPlotAccessor.hist(*args, **kwargs) -> tuple[np.ndarray, np.ndarray, BarContainer | Polygon]
- changed:
function hist(darray: DataArray, *args: Any, figsize: Iterable[float] | None=…, size: float | None=…, aspect: AspectOptions=…, ax: Axes | None=…, xincrease: bool | None=…, yincrease: bool | None=…, xscale: ScaleOptions=…, yscale: ScaleOptions=…, xticks: ArrayLike | None=…, yticks: ArrayLike | None=…, xlim: ArrayLike | None=…, ylim: ArrayLike | None=…, **kwargs: Any) -> tuple[np.ndarray, np.ndarra… → function hist(darray: DataArray, *args: Any, figsize: Iterable[float] | None=…, size: float | None=…, aspect: AspectOptions=…, ax: Axes | None=…, xincrease: bool | None=…, yincrease: bool | None=…, xscale: ScaleOptions=…, yscale: ScaleOptions=…, xticks: ArrayLike | None=…, yticks: ArrayLike | None=…, xlim: tuple[float, float] | None=…, ylim: tuple[float, float] | None=…, **kwargs: Any) -> tuple[n…
- changed:
class FacetGrid(Generic[T_Xarray]) → class FacetGrid(Generic[T_DataArrayOrSet]) - changed:
constructor FacetGrid(data: T_Xarray, col: Hashable | None=…, row: Hashable | None=…, col_wrap: int | None=…, sharex: bool=…, sharey: bool=…, figsize: Iterable[float] | None=…, aspect: float=…, size: float=…, subplot_kws: dict[str, Any] | None=…) -> None → constructor FacetGrid(data: T_DataArrayOrSet, col: Hashable | None=…, row: Hashable | None=…, col_wrap: int | None=…, sharex: bool=…, sharey: bool=…, figsize: Iterable[float] | None=…, aspect: float=…, size: float=…, subplot_kws: dict[str, Any] | None=…) -> None - changed:
field FacetGrid.data: T_Xarray → field FacetGrid.data: T_DataArrayOrSet - changed:
method FacetGrid.map_plot1d(func: Callable, x: Hashable | None, y: Hashable | None, **kwargs: Any) -> T_FacetGrid → method FacetGrid.map_plot1d(func: Callable, x: Hashable | None, y: Hashable | None, *, z: Hashable | None=…, hue: Hashable | None=…, markersize: Hashable | None=…, linewidth: Hashable | None=…, **kwargs: Any) -> T_FacetGrid
- removed:
function import_matplotlib_pyplot() - changed:
function label_from_attrs(da, extra: str=…) -> str → function label_from_attrs(da: DataArray | None, extra: str=…) -> str
- removed:
function open_rasterio(name, engine=…, cache=…, cache_dir=…, **kws) - removed:
variable external_rasterio_urls
- added:
function deprecate_dims(func: T) -> T - added:
variable T
- removed:
constructor AggregationGenerator(cls, datastructure, methods, docref, docref_description, example_call_preamble, definition_preamble, see_also_obj=…) - removed:
field DataStructure.docstring_create: str - removed:
variable DEFAULT_PREAMBLE - removed:
variable filepath - changed:
constructor Method(name, bool_reduce=…, extra_kwargs=…, numeric_only=…) → constructor Method(name, bool_reduce=…, extra_kwargs=…, numeric_only=…, see_also_modules=…) - changed:
method GenericAggregationGenerator.generate_code(method) → method GenericAggregationGenerator.generate_code(method, has_keep_attrs) - changed:
method GroupByAggregationGenerator.generate_code(method) → method GroupByAggregationGenerator.generate_code(method, has_keep_attrs) - added:
field AggregationGenerator.cls: str - added:
field AggregationGenerator.datastructure: DataStructure - added:
field AggregationGenerator.definition_preamble: str - added:
field AggregationGenerator.docref: str - added:
field AggregationGenerator.docref_description: str - added:
field AggregationGenerator.example_call_preamble: str - added:
field AggregationGenerator.has_keep_attrs: bool - added:
field AggregationGenerator.methods: tuple[Method, ...] - added:
field AggregationGenerator.notes: str - added:
field AggregationGenerator.preamble: str - added:
field DataStructure.create_example: str - added:
field DataStructure.see_also_modules: tuple[str] - added:
function write_methods(filepath, generators, preamble) - added:
variable AGGREGATIONS_PREAMBLE - added:
variable NAMED_ARRAY_AGGREGATIONS_PREAMBLE - added:
variable NAMED_ARRAY_GENERATOR - added:
variable NAMED_ARRAY_MODULE_PREAMBLE - added:
variable NAMED_ARRAY_OBJECT
- removed:
variable NO_OVERRIDE - removed:
variable OVERRIDE_TYPESHED - removed:
variable STUBFILE_PREAMBLE - removed:
variable is_module - removed:
variable option - removed:
variable stub_da - removed:
variable stub_dagb - removed:
variable stub_ds - removed:
variable stub_dsgb - removed:
variable stub_other_unary - removed:
variable stub_required_binary - removed:
variable stub_required_inplace - removed:
variable stub_required_unary - removed:
variable stub_unary - removed:
variable stub_var - changed:
function binops(stub=…) → function binops(other_type: str, return_type: str=…, type_ignore_eq: str=…) -> list[OpsType] - changed:
function inplace() → function inplace(other_type: str, type_ignore: str=…) -> list[OpsType] - changed:
function render(ops_info, is_module) → function render(ops_info: dict[str, list[OpsType]]) -> Iterator[str] - changed:
function unops(self_type) → function unops() -> list[OpsType] - added:
function binops_overload(other_type: str, overload_type: str, return_type: str=…, type_ignore_eq: str=…) -> list[OpsType] - added:
variable FuncType - added:
variable OpsType - added:
variable template_binop_overload - added:
variable unhashable