Upgrading xarray 2023 to 2024
Breaking2023.12.0 → 2024.11.0Breaking6Deprecated1New25Changed31Fixed22Other62
BreakingUpgrade verdict
6 breaking changes.
In plain terms
- Removes unvetted DataTree methods.
- Renames inherited to inherit in DataTree.to_dataset.
- Renames map_over_subtree to map_over_datasets.
- Forbids modifying names of DataTree objects that have parents.
Must act Top 4 of 7 that need code or config changes
Python requirement changed in 2024.9.0: >=3.9 → >=3.10.
What you must change
Breaking6
Removes unvetted DataTree methods.
DataTreeRenames inherited to inherit in DataTree.to_dataset.
DataTree.to_datasetRenames map_over_subtree to map_over_datasets.
map_over_subtreemap_over_datasetsForbids modifying names of DataTree objects that have parents.
DataTreeUpdates compat error checking to disallow "minimal" in concat().
concat()compatStops inheriting non-indexed coordinates for DataTree.
DataTreeDeprecations to plan for
Deprecated1
Documents deprecation of the squeeze kwarg in groupby.
squeezeAPI changes
Generated by DepDelta from published Python source. Not mixed with prose notes.
- added:
export DataTree - added:
export InvalidTreeError - added:
export NamedArray - added:
export NotFoundInTreeError - added:
export TreeIsomorphismError - added:
export group_subtrees - added:
export groupers - added:
export map_over_datasets - added:
export open_datatree - added:
export open_groups - added:
export register_datatree_accessor - added:
export ufuncs
- removed:
export NioDataStore
- changed:
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',… → function open_dataarray(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, engine: T_Engine | None=…, chunks: T_Chunks | None=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | None=…, decode_times: bool | None=…, decode_timedelta: bool | None=…, use_cftime: bool | None=…, concat_characters: bool | None=…, decode_coords: Literal['coordinates', 'all… - changed:
function open_dataset(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_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, engine: T_Engine=…, chunks: T_Chunks=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | Mapping[str, bool] | None=…, decode_times: bool | Mapping[str, bool] | None=…, decode_timedelta: bool | Mapping[str, bool] | None=…, use_cftime: bool | Mapping[str, bool] | None=…, concat_c… - changed:
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… → function open_mfdataset(paths: str | os.PathLike | ReadBuffer | NestedSequence[str | os.PathLike | ReadBuffer], chunks: T_Chunks | None=…, concat_dim: str | DataArray | Index | Sequence[str] | Sequence[DataArray] | Sequence[Index] | None=…, compat: CompatOptions=…, preprocess: Callable[[Dataset], Dataset] | None=…, engine: T_Engine | None=…, data_vars: Literal['all', 'minimal', 'different'] | lis… - changed:
function to_netcdf(dataset: Dataset, path_or_file: str | os.PathLike | None=…, mode: Literal['w', 'a']=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Hashable, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, *, multifile: Literal[True], invalid_netcdf: bool=…) -> tuple[ArrayWriter, AbstractDataS… → function to_netcdf(dataset: Dataset, path_or_file: str | os.PathLike | None=…, mode: NetcdfWriteModes=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Hashable, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, *, multifile: Literal[True], invalid_netcdf: bool=…, auto_complex: bool | None=…) -> tupl… - added:
function open_datatree(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, engine: T_Engine=…, chunks: T_Chunks=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | Mapping[str, bool] | None=…, decode_times: bool | Mapping[str, bool] | None=…, decode_timedelta: bool | Mapping[str, bool] | None=…, use_cftime: bool | Mapping[str, bool] | None=…, concat_… - added:
function open_groups(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, engine: T_Engine=…, chunks: T_Chunks=…, cache: bool | None=…, decode_cf: bool | None=…, mask_and_scale: bool | Mapping[str, bool] | None=…, decode_times: bool | Mapping[str, bool] | None=…, decode_timedelta: bool | Mapping[str, bool] | None=…, use_cftime: bool | Mapping[str, bool] | None=…, concat_ch…
- changed:
method BackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool → method BackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool - changed:
method BackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore, *, drop_variables: str | Iterable[str] | None=…, **kwargs: Any) -> Dataset → method BackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, drop_variables: str | Iterable[str] | None=…) -> Dataset - added:
function datatree_from_dict_with_io_cleanup(groups_dict: Mapping[str, Dataset]) -> DataTree - added:
method BackendEntrypoint.open_datatree(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, drop_variables: str | Iterable[str] | None=…) -> DataTree - added:
method BackendEntrypoint.open_groups_as_dict(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, drop_variables: str | Iterable[str] | None=…) -> dict[str, Dataset] - added:
variable T
- removed:
function maybe_decode_bytes(txt) - changed:
method H5netcdfBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool → method H5netcdfBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool - changed:
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 → method H5netcdfBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, format=…, group=…, lock=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=…, storage_options:… - changed:
static method H5NetCDFStore.open(filename, mode=…, format=…, group=…, lock=…, autoclose=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=…) → static method H5NetCDFStore.open(filename, mode=…, format=…, group=…, lock=…, autoclose=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=…, storage_options: dict[str, Any] | None=…) - added:
method H5netcdfBackendEntrypoint.open_datatree(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, format=…, group: str | None=…, lock=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=…, **kw… - added:
method H5netcdfBackendEntrypoint.open_groups_as_dict(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, format=…, group: str | None=…, lock=…, invalid_netcdf=…, phony_dims=…, decode_vlen_strings=…, driver=…, driver_kwds=……
- removed:
variable SerializableLock - added:
class SerializableLock - added:
constructor SerializableLock(token: Hashable | None=…) - added:
field SerializableLock.lock: threading.Lock - added:
field SerializableLock.token: Hashable - added:
method SerializableLock.acquire(*args, **kwargs) - added:
method SerializableLock.locked() - added:
method SerializableLock.release(*args, **kwargs)
- changed:
method NetCDF4BackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool → method NetCDF4BackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool - changed:
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 → method NetCDF4BackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group=…, mode=…, format=…, clobber=…, diskless=…, persist=…, auto_complex=…, lock=…, autoclose=…) -> Dataset - changed:
method NetCDF4DataStore.open_store_variable(name, var) → method NetCDF4DataStore.open_store_variable(name: str, var) - changed:
method NetCDF4DataStore.prepare_variable(name, variable, check_encoding=…, unlimited_dims=…) → method NetCDF4DataStore.prepare_variable(name, variable: Variable, check_encoding=…, unlimited_dims=…) - changed:
static method NetCDF4DataStore.open(filename, mode=…, format=…, group=…, clobber=…, diskless=…, persist=…, lock=…, lock_maker=…, autoclose=…) → static method NetCDF4DataStore.open(filename, mode=…, format=…, group=…, clobber=…, diskless=…, persist=…, auto_complex=…, lock=…, lock_maker=…, autoclose=…) - added:
method NetCDF4BackendEntrypoint.open_datatree(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, format=…, clobber=…, diskless=…, persist=…, auto_complex=…, lock=…, autoclose=…, **kwargs) -> DataTree - added:
method NetCDF4BackendEntrypoint.open_groups_as_dict(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, format=…, clobber=…, diskless=…, persist=…, auto_complex=…, lock=…, autoclose=…, **kwargs) -> dic…
- added:
variable COERCION_VALUE_ERROR
- removed:
variable EntryPoints - changed:
function guess_engine(store_spec: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> str | type[BackendEntrypoint] → function guess_engine(store_spec: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> str | type[BackendEntrypoint]
- changed:
method PydapBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool → method PydapBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool - changed:
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 → method PydapBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, application=…, session=…, output_grid=…, timeout=…, verify=…, user_charset=…) -> Dataset
- removed:
class NioArrayWrapper(BackendArray) - removed:
class NioDataStore(AbstractDataStore) - removed:
class PynioBackendEntrypoint(BackendEntrypoint) - removed:
constructor NioArrayWrapper(variable_name, datastore) - removed:
constructor NioDataStore(filename, mode=…, lock=…, **kwargs) - removed:
method NioArrayWrapper.get_array(needs_lock=…) - removed:
method NioDataStore.close() - removed:
method NioDataStore.get_attrs() - removed:
method NioDataStore.get_dimensions() - removed:
method NioDataStore.get_encoding() - removed:
method NioDataStore.get_variables() - removed:
method NioDataStore.open_store_variable(name, var) - removed:
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:
property NioDataStore.ds - removed:
variable NCL_LOCK - removed:
variable PYNIO_LOCK
- changed:
method ScipyBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool → method ScipyBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool - changed:
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 → method ScipyBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, mode=…, format=…, group=…, mmap=…, lock=…) -> Dataset - added:
variable HAS_NUMPY_2_0
- changed:
method StoreBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool → method StoreBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool - changed:
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 → method StoreBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…) -> Dataset
- changed:
constructor ZarrStore(zarr_group, mode=…, consolidate_on_close=…, append_dim=…, write_region=…, safe_chunks=…, write_empty: bool | None=…, close_store_on_close: bool=…) → constructor ZarrStore(zarr_group, mode=…, consolidate_on_close=…, append_dim=…, write_region=…, safe_chunks=…, write_empty: bool | None=…, close_store_on_close: bool=…, use_zarr_fill_value_as_mask=…) - changed:
function extract_zarr_variable_encoding(variable, raise_on_invalid=…, name=…, safe_chunks=…) → function extract_zarr_variable_encoding(variable, raise_on_invalid=…, name=…, *, safe_chunks=…, region=…, mode=…, shape=…) - 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=…, chunked_array_type: str | None=…, from_array_kwargs: dict[str, Any] | None=…, **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=…, zarr_format=…, use_zarr_fill_value_as_mask=…, chunked_array_type: str | None=…, from_array_kwargs: dict[str… - changed:
method ZarrBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | BufferedIOBase | AbstractDataStore) -> bool → method ZarrBackendEntrypoint.guess_can_open(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore) -> bool - changed:
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 → method ZarrBackendEntrypoint.open_dataset(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group=…, mode=…, synchronizer=…, consolidated=…, chunk_store=…, storage_options=…, zarr_version=…, zarr_format=…, store=…, engin… - changed:
method ZarrStore.close() → method ZarrStore.close() -> None - changed:
method ZarrStore.open_store_variable(name, zarr_array) → method ZarrStore.open_store_variable(name, zarr_array=…) - changed:
static method ZarrStore.open_group(store, mode: ZarrWriteModes=…, synchronizer=…, group=…, consolidated=…, consolidate_on_close=…, chunk_store=…, storage_options=…, append_dim=…, write_region=…, safe_chunks=…, stacklevel=…, zarr_version=…, write_empty: bool | None=…) → static method ZarrStore.open_group(store, mode: ZarrWriteModes=…, synchronizer=…, group=…, consolidated=…, consolidate_on_close=…, chunk_store=…, storage_options=…, append_dim=…, write_region=…, safe_chunks=…, zarr_version=…, zarr_format=…, use_zarr_fill_value_as_mask=…, write_empty: bool | None=…) - added:
class FillValueCoder - added:
method ZarrBackendEntrypoint.open_datatree(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, mode=…, synchronizer=…, consolidated=…, chunk_store=…, storage_options=…, zarr_version=…, zarr_format=…) -… - added:
method ZarrBackendEntrypoint.open_groups_as_dict(filename_or_obj: str | os.PathLike[Any] | ReadBuffer | AbstractDataStore, *, mask_and_scale=…, decode_times=…, concat_characters=…, decode_coords=…, drop_variables: str | Iterable[str] | None=…, use_cftime=…, decode_timedelta=…, group: str | None=…, mode=…, synchronizer=…, consolidated=…, chunk_store=…, storage_options=…, zarr_version=…, zarr_forma… - added:
static method FillValueCoder.decode(value: int | float | str | bytes, dtype: str | np.dtype[Any]) - added:
static method FillValueCoder.encode(value: int | float | str | bytes, dtype: np.dtype[Any]) -> Any - added:
static method ZarrStore.open_store(store, mode: ZarrWriteModes=…, synchronizer=…, group=…, consolidated=…, consolidate_on_close=…, chunk_store=…, storage_options=…, append_dim=…, write_region=…, safe_chunks=…, zarr_version=…, zarr_format=…, use_zarr_fill_value_as_mask=…, write_empty: bool | None=…) - added:
variable ZarrFormat
- removed:
variable cftime - changed:
constructor BaseCFTimeOffset(n: int=…) → constructor BaseCFTimeOffset(n: int=…) -> None - changed:
constructor QuarterOffset(n=…, month=…) → constructor QuarterOffset(n: int=…, month: int | None=…) -> None - changed:
constructor YearOffset(n=…, month=…) → constructor YearOffset(n: int=…, month: int | None=…) -> None - changed:
function cftime_range(start=…, end=…, periods=…, freq=…, normalize=…, name=…, closed: NoDefault | SideOptions=…, inclusive: None | InclusiveOptions=…, calendar=…) → function cftime_range(start=…, end=…, periods=…, freq=…, normalize=…, name=…, closed: NoDefault | SideOptions=…, inclusive: None | InclusiveOptions=…, calendar=…) -> CFTimeIndex - changed:
function roll_qtrday(other, n, month, day_option, modby=…) → function roll_qtrday(other, n: int, month: int, day_option: DayOption, modby: int=…) -> int - changed:
function to_offset(freq) → function to_offset(freq: BaseCFTimeOffset | str | timedelta | pd.Timedelta | pd.DateOffset, warn: bool=…) -> BaseCFTimeOffset - changed:
method BaseCFTimeOffset.onOffset(date) → method BaseCFTimeOffset.onOffset(date) -> bool - changed:
method BaseCFTimeOffset.rule_code() → method BaseCFTimeOffset.rule_code() -> str | None - changed:
method Day.as_timedelta() → method Day.as_timedelta() -> timedelta - changed:
method Hour.as_timedelta() → method Hour.as_timedelta() -> timedelta - changed:
method Microsecond.as_timedelta() → method Microsecond.as_timedelta() -> timedelta - changed:
method Millisecond.as_timedelta() → method Millisecond.as_timedelta() -> timedelta - changed:
method Minute.as_timedelta() → method Minute.as_timedelta() -> timedelta - changed:
method MonthBegin.onOffset(date) → method MonthBegin.onOffset(date) -> bool - changed:
method MonthEnd.onOffset(date) → method MonthEnd.onOffset(date) -> bool - changed:
method QuarterOffset.onOffset(date) → method QuarterOffset.onOffset(date) -> bool - changed:
method QuarterOffset.rule_code() → method QuarterOffset.rule_code() -> str - changed:
method Second.as_timedelta() → method Second.as_timedelta() -> timedelta - changed:
method Tick.as_timedelta() → method Tick.as_timedelta() -> timedelta - changed:
method YearBegin.onOffset(date) → method YearBegin.onOffset(date) -> bool - changed:
method YearEnd.onOffset(date) → method YearEnd.onOffset(date) -> bool - changed:
method YearOffset.rule_code() → method YearOffset.rule_code() -> str - added:
field BaseCFTimeOffset.n: int - added:
field QuarterOffset.month: int - added:
field YearOffset.month: int - added:
function delta_to_tick(delta: timedelta | pd.Timedelta) -> Tick - added:
variable DayOption: TypeAlias - added:
variable T_FreqStr
- removed:
variable cftime - changed:
method CFTimeIndex.contains(key) → method CFTimeIndex.contains(key: Any) -> bool - changed:
method CFTimeIndex.shift(n: int | float, freq: str | timedelta) → method CFTimeIndex.shift(periods: int | float, freq: str | timedelta | BaseCFTimeOffset | None=…) -> Self - added:
property CFTimeIndex.is_leap_year
- changed:
function ensure_fixed_length_bytes(var) → function ensure_fixed_length_bytes(var: Variable) -> Variable - changed:
method EncodedStringCoder.decode(variable, name=…) → method EncodedStringCoder.decode(variable: Variable, name=…) -> Variable - changed:
method EncodedStringCoder.encode(variable, name=…) → method EncodedStringCoder.encode(variable: Variable, name=…) -> Variable - added:
variable HAS_NUMPY_2_0
- changed:
function encode_cf_datetime(dates, units: str | None=…, calendar: str | None=…, dtype: np.dtype | None=…) -> tuple[np.ndarray, str, str] → function encode_cf_datetime(dates: T_DuckArray, units: str | None=…, calendar: str | None=…, dtype: np.dtype | None=…) -> tuple[T_DuckArray, str, str] - changed:
function encode_cf_timedelta(timedeltas, units: str | None=…, dtype: np.dtype | None=…) -> tuple[np.ndarray, str] → function encode_cf_timedelta(timedeltas: T_DuckArray, units: str | None=…, dtype: np.dtype | None=…) -> tuple[T_DuckArray, str]
- removed:
class UnsignedIntegerCoder(VariableCoder) - removed:
method UnsignedIntegerCoder.decode(variable: Variable, name: T_Name=…) -> Variable - removed:
method UnsignedIntegerCoder.encode(variable: Variable, name: T_Name=…) -> Variable - added:
class NativeEnumCoder(VariableCoder) - added:
class Numpy2StringDTypeCoder(VariableCoder) - added:
method NativeEnumCoder.decode(variable: Variable, name: T_Name=…) -> Variable - added:
method NativeEnumCoder.encode(variable: Variable, name: T_Name=…) -> Variable - added:
method Numpy2StringDTypeCoder.decode(variable: Variable, name: T_Name=…) -> Variable - added:
method Numpy2StringDTypeCoder.encode()
- changed:
function cf_encoder(variables, attributes) → function cf_encoder(variables: T_Variables, attributes: T_Attrs) - changed:
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]] → function decode_cf_variables(variables: T_Variables, attributes: T_Attrs, concat_characters: bool | Mapping[str, bool]=…, mask_and_scale: bool | Mapping[str, bool]=…, decode_times: bool | Mapping[str, bool]=…, decode_coords: bool | Literal['coordinates', 'all']=…, drop_variables: T_DropVariables=…, use_cftime: bool | Mapping[str, bool] | None=…, decode_timedelta: bool | Mapping[str, bool] | None=… - changed:
function encode_dataset_coordinates(dataset) → function encode_dataset_coordinates(dataset: Dataset) - added:
variable T
- removed:
property DatetimeAccessor.weekday_name -> T_DataArray - added:
property DatetimeAccessor.days_in_year -> T_DataArray - added:
property DatetimeAccessor.decimal_year -> T_DataArray
- changed:
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=…) → constructor Aligner(objects: Iterable[T_Alignable], join: str=…, indexes: Mapping[Any, Any] | None=…, exclude_dims: str | Iterable[Hashable]=…, exclude_vars: Iterable[Hashable]=…, method: str | None=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value: Any=…, sparse: bool=…) - changed:
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 → function reindex(obj: T_Alignable, indexers: Mapping[Any, Any], method: str | None=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value: Any=…, sparse: bool=…, exclude_vars: Iterable[Hashable]=…) -> T_Alignable - changed:
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 → function reindex_like(obj: T_Alignable, other: Dataset | DataArray, method: str | None=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value: Any=…) -> T_Alignable
- added:
function is_weak_scalar_type(t) - added:
function result_type(*arrays_and_dtypes, xp) -> np.dtype
- added:
variable T
- changed:
method AbstractArray.get_axis_num(dim: Hashable | Iterable[Hashable]) -> int | tuple[int, ...] → method AbstractArray.get_axis_num(dim: Iterable[Hashable]) -> tuple[int, ...] | (dim: Hashable) -> int - added:
class TreeAttrAccessMixin(AttrAccessMixin)
- removed:
function result_name(objects: Iterable[Any]) -> Any - changed:
function corr(da_a: T_DataArray, da_b: T_DataArray, dim: Dims=…) -> T_DataArray → function corr(da_a: T_DataArray, da_b: T_DataArray, dim: Dims=…, weights: T_DataArray | None=…) -> T_DataArray - changed:
function cov(da_a: T_DataArray, da_b: T_DataArray, dim: Dims=…, ddof: int=…) -> T_DataArray → function cov(da_a: T_DataArray, da_b: T_DataArray, dim: Dims=…, ddof: int=…, weights: T_DataArray | None=…) -> T_DataArray
- changed:
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… → function concat(objs: Iterable[T_Dataset], dim: Hashable | T_Variable | T_DataArray | pd.Index | Any, data_vars: T_DataVars=…, coords: ConcatOptions | list[Hashable]=…, compat: CompatOptions=…, positions: Iterable[Iterable[int]] | None=…, fill_value: object=…, join: JoinOptions=…, combine_attrs: CombineAttrsOptions=…, create_index_for_new_dim: bool=…) -> T_Dataset | (objs: Iterable[T_DataArray],…
- changed:
static method Coordinates.from_pandas_multiindex(midx: pd.MultiIndex, dim: str) -> Self → static method Coordinates.from_pandas_multiindex(midx: pd.MultiIndex, dim: Hashable) -> Self - added:
class DataTreeCoordinates(Coordinates) - added:
constructor DataTreeCoordinates(datatree: DataTree) - added:
method DataTreeCoordinates.to_dataset() -> Dataset - added:
property DataTreeCoordinates.dims -> Frozen[Hashable, int] - added:
property DataTreeCoordinates.dtypes -> Frozen[Hashable, np.dtype] - added:
property DataTreeCoordinates.variables -> Mapping[Hashable, Variable]
- added:
function reshape_blockwise(x: Any, shape: int | tuple[int, ...], chunks: tuple[tuple[int, ...], ...] | None=…) - added:
function sliding_window_view(x, window_shape, axis=…, *, automatic_rechunk=…, **kwargs)
- changed:
function push(array, n, axis) → function push(array, n, axis, method=…)
- removed:
class DaskManager(ChunkManagerEntrypoint['DaskArray']) - removed:
constructor DaskManager() -> None - removed:
field DaskManager.array_cls: type[DaskArray] - removed:
field DaskManager.available: bool - removed:
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) - removed:
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) - removed:
method DaskManager.chunks(data: DaskArray) -> T_NormalizedChunks - removed:
method DaskManager.compute(*data: DaskArray, **kwargs) -> tuple[np.ndarray, ...] - removed:
method DaskManager.from_array(data: Any, chunks, **kwargs) -> DaskArray - removed:
method DaskManager.is_chunked_array(data: Any) -> bool - removed:
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) - removed:
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 - removed:
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 - removed:
method DaskManager.store(sources: DaskArray | Sequence[DaskArray], targets: Any, **kwargs) - removed:
method DaskManager.unify_chunks(*args: Any, **kwargs) -> tuple[dict[str, T_NormalizedChunks], list[DaskArray]] - removed:
property DaskManager.array_api -> Any
- removed:
property DataArray.xindexes -> Indexes - removed:
variable DaskDataFrame - removed:
variable Delayed - removed:
variable iris_Cube - 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: Mapping[Any, Index] | None=…, fastpath: bool=…) -> None → constructor DataArray(data: Any=…, coords: Sequence[Sequence | pd.Index | DataArray | Variable | np.ndarray] | Mapping | None=…, dims: str | Iterable[Hashable] | None=…, name: Hashable | None=…, attrs: Mapping | None=…, indexes: Mapping[Hashable, Index] | None=…, fastpath: bool=…) -> None - changed:
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 → method DataArray.chunk(chunks: T_ChunksFreq=…, *, name_prefix: str=…, token: str | None=…, lock: bool=…, inline_array: bool=…, chunked_array_type: str | ChunkManagerEntrypoint | None=…, from_array_kwargs=…, **chunks_kwargs: T_ChunkDimFreq) -> Self - changed:
method DataArray.expand_dims(dim: None | Hashable | Sequence[Hashable] | Mapping[Any, Any]=…, axis: None | int | Sequence[int]=…, **dim_kwargs: Any) -> Self → method DataArray.expand_dims(dim: None | Hashable | Sequence[Hashable] | Mapping[Any, Any]=…, axis: None | int | Sequence[int]=…, create_index_for_new_dim: bool=…, **dim_kwargs: Any) -> Self - changed:
method DataArray.groupby(group: Hashable | DataArray | IndexVariable, squeeze: bool=…, restore_coord_dims: bool=…) -> DataArrayGroupBy → method DataArray.groupby(group: GroupInput=…, *, squeeze: Literal[False]=…, restore_coord_dims: bool=…, eagerly_compute_group: bool=…, **groupers: Grouper) -> DataArrayGroupBy - changed:
method DataArray.groupby_bins(group: Hashable | DataArray | IndexVariable, bins: ArrayLike, right: bool=…, labels: ArrayLike | Literal[False] | None=…, precision: int=…, include_lowest: bool=…, squeeze: bool=…, restore_coord_dims: bool=…) -> DataArrayGroupBy → method DataArray.groupby_bins(group: Hashable | DataArray | IndexVariable, bins: Bins, right: bool=…, labels: ArrayLike | Literal[False] | None=…, precision: int=…, include_lowest: bool=…, squeeze: Literal[False]=…, restore_coord_dims: bool=…, duplicates: Literal['raise', 'drop']=…, eagerly_compute_group: bool=…) -> DataArrayGroupBy - changed:
method DataArray.reindex(indexers: Mapping[Any, Any] | None=…, *, method: ReindexMethodOptions=…, tolerance: float | Iterable[float] | None=…, copy: bool=…, fill_value=…, **indexers_kwargs: Any) -> Self → method DataArray.reindex(indexers: Mapping[Any, Any] | None=…, *, method: ReindexMethodOptions=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value=…, **indexers_kwargs: Any) -> Self - changed:
method DataArray.reindex_like(other: T_DataArrayOrSet, *, method: ReindexMethodOptions=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value=…) -> Self → method DataArray.reindex_like(other: T_DataArrayOrSet, *, method: ReindexMethodOptions=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value=…) -> 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=…, loffset: datetime.timedelta | str | None=…, restore_coord_dims: bool | None=…, **indexer_kwargs: str) -> DataArrayResample → method DataArray.resample(indexer: Mapping[Hashable, ResampleCompatible | Resampler] | None=…, *, skipna: bool | None=…, closed: SideOptions | None=…, label: SideOptions | None=…, offset: pd.Timedelta | datetime.timedelta | str | None=…, origin: str | DatetimeLike=…, restore_coord_dims: bool | None=…, **indexer_kwargs: ResampleCompatible | Resampler) -> DataArrayResample - changed:
method DataArray.stack(dimensions: Mapping[Any, Sequence[Hashable]] | None=…, create_index: bool | None=…, index_cls: type[Index]=…, **dimensions_kwargs: Sequence[Hashable]) -> Self → method DataArray.stack(dim: Mapping[Any, Sequence[Hashable]] | None=…, create_index: bool | None=…, index_cls: type[Index]=…, **dim_kwargs: Sequence[Hashable | EllipsisType]) -> Self - changed:
method DataArray.to_netcdf(path: None=…, mode: Literal['w', 'a']=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Hashable, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, invalid_netcdf: bool=…) -> bytes | (path: str | PathLike, mode: Literal['w', 'a']=…, format: T_NetcdfTypes | None=…, group: st… → method DataArray.to_netcdf(path: None=…, mode: NetcdfWriteModes=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Hashable, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, invalid_netcdf: bool=…, auto_complex: bool | None=…) -> bytes | (path: str | PathLike, mode: NetcdfWriteModes=…, format: T_Netc… - changed:
method DataArray.to_zarr(store: MutableMapping | str | PathLike[str] | None=…, chunk_store: MutableMapping | str | PathLike | None=…, mode: ZarrWriteModes | None=…, synchronizer=…, group: str | None=…, *, encoding: Mapping | None=…, compute: Literal[True]=…, consolidated: bool | None=…, append_dim: Hashable | None=…, region: Mapping[str, slice] | None=…, safe_chunks: bool=…, storage_options: dict… → method DataArray.to_zarr(store: MutableMapping | str | PathLike[str] | None=…, chunk_store: MutableMapping | str | PathLike | None=…, mode: ZarrWriteModes | None=…, synchronizer=…, group: str | None=…, *, encoding: Mapping | None=…, compute: Literal[True]=…, consolidated: bool | None=…, append_dim: Hashable | None=…, region: Mapping[str, slice | Literal['auto']] | Literal['auto'] | None=…, safe_c… - changed:
method DataArray.transpose(*dims: Hashable, transpose_coords: bool=…, missing_dims: ErrorOptionsWithWarn=…) -> Self → method DataArray.transpose(*dim: Hashable, transpose_coords: bool=…, missing_dims: ErrorOptionsWithWarn=…) -> Self - added:
method DataArray.cumulative(dim: str | Iterable[Hashable], min_periods: int=…) -> DataArrayRolling - added:
method DataArray.drop_attrs(*, deep: bool=…) -> Self - added:
property DataArray.xindexes -> Indexes[Index]
- removed:
variable DaskDataFrame - removed:
variable Delayed - changed:
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 → method Dataset.chunk(chunks: T_ChunksFreq=…, name_prefix: str=…, token: str | None=…, lock: bool=…, inline_array: bool=…, chunked_array_type: str | ChunkManagerEntrypoint | None=…, from_array_kwargs=…, **chunks_kwargs: T_ChunkDimFreq) -> Self - changed:
method Dataset.expand_dims(dim: None | Hashable | Sequence[Hashable] | Mapping[Any, Any]=…, axis: None | int | Sequence[int]=…, **dim_kwargs: Any) -> Self → method Dataset.expand_dims(dim: None | Hashable | Sequence[Hashable] | Mapping[Any, Any]=…, axis: None | int | Sequence[int]=…, create_index_for_new_dim: bool=…, **dim_kwargs: Any) -> Self - changed:
method Dataset.groupby(group: Hashable | DataArray | IndexVariable, squeeze: bool=…, restore_coord_dims: bool=…) -> DatasetGroupBy → method Dataset.groupby(group: GroupInput=…, *, squeeze: Literal[False]=…, restore_coord_dims: bool=…, eagerly_compute_group: bool=…, **groupers: Grouper) -> DatasetGroupBy - changed:
method Dataset.groupby_bins(group: Hashable | DataArray | IndexVariable, bins: ArrayLike, right: bool=…, labels: ArrayLike | None=…, precision: int=…, include_lowest: bool=…, squeeze: bool=…, restore_coord_dims: bool=…) -> DatasetGroupBy → method Dataset.groupby_bins(group: Hashable | DataArray | IndexVariable, bins: Bins, right: bool=…, labels: ArrayLike | None=…, precision: int=…, include_lowest: bool=…, squeeze: Literal[False]=…, restore_coord_dims: bool=…, duplicates: Literal['raise', 'drop']=…, eagerly_compute_group: bool=…) -> DatasetGroupBy - 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) -> Self → 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 | None=…, **kwargs: Any) -> 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=…, keep_attrs: bool | N… → 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: T_DatasetPadConstantValues | None=…, end_values: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, reflect_type: PadReflectOptions=…, keep_attrs: bool | None=…, **pad_width_kwargs: Any) -> Se… - 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) -> Self → method Dataset.reindex(indexers: Mapping[Any, Any] | None=…, method: ReindexMethodOptions=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value: Any=…, **indexers_kwargs: Any) -> Self - changed:
method Dataset.reindex_like(other: T_Xarray, method: ReindexMethodOptions=…, tolerance: int | float | Iterable[int | float] | None=…, copy: bool=…, fill_value: Any=…) -> Self → method Dataset.reindex_like(other: T_Xarray, method: ReindexMethodOptions=…, tolerance: float | Iterable[float] | str | None=…, copy: bool=…, fill_value: Any=…) -> 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=…, loffset: datetime.timedelta | str | None=…, restore_coord_dims: bool | None=…, **indexer_kwargs: str) -> DatasetResample → method Dataset.resample(indexer: Mapping[Any, ResampleCompatible | Resampler] | None=…, *, skipna: bool | None=…, closed: SideOptions | None=…, label: SideOptions | None=…, offset: pd.Timedelta | datetime.timedelta | str | None=…, origin: str | DatetimeLike=…, restore_coord_dims: bool | None=…, **indexer_kwargs: ResampleCompatible | Resampler) -> DatasetResample - changed:
method Dataset.stack(dimensions: Mapping[Any, Sequence[Hashable | ellipsis]] | None=…, create_index: bool | None=…, index_cls: type[Index]=…, **dimensions_kwargs: Sequence[Hashable | ellipsis]) -> Self → method Dataset.stack(dim: Mapping[Any, Sequence[Hashable | EllipsisType]] | None=…, create_index: bool | None=…, index_cls: type[Index]=…, **dim_kwargs: Sequence[Hashable | EllipsisType]) -> Self - changed:
method Dataset.to_netcdf(path: None=…, mode: Literal['w', 'a']=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Any, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, invalid_netcdf: bool=…) -> bytes | (path: str | PathLike, mode: Literal['w', 'a']=…, format: T_NetcdfTypes | None=…, group: str | Non… → method Dataset.to_netcdf(path: None=…, mode: NetcdfWriteModes=…, format: T_NetcdfTypes | None=…, group: str | None=…, engine: T_NetcdfEngine | None=…, encoding: Mapping[Any, Mapping[str, Any]] | None=…, unlimited_dims: Iterable[Hashable] | None=…, compute: bool=…, invalid_netcdf: bool=…, auto_complex: bool | None=…) -> bytes | (path: str | PathLike, mode: NetcdfWriteModes=…, format: T_NetcdfTypes… - changed:
method Dataset.transpose(*dims: Hashable, missing_dims: ErrorOptionsWithWarn=…) -> Self → method Dataset.transpose(*dim: Hashable, missing_dims: ErrorOptionsWithWarn=…) -> Self - added:
method Dataset.cumulative(dim: str | Iterable[Hashable], min_periods: int=…) -> DatasetRolling - added:
method Dataset.drop_attrs(*, deep: bool=…) -> Self
- added:
class DataTree(NamedNode['DataTree'], DataTreeAggregations, DataTreeOpsMixin, TreeAttrAccessMixin, Mapping[str, 'DataArray | DataTree']) - added:
class DatasetView(Dataset) - added:
constructor DataTree(dataset: Dataset | Coordinates | None=…, children: Mapping[str, DataTree] | None=…, name: str | None=…) - added:
constructor DatasetView(data_vars: Mapping[Any, Any] | None=…, coords: Mapping[Any, Any] | None=…, attrs: Mapping[Any, Any] | None=…) - added:
field DataTree.ds - added:
function check_alignment(path: str, node_ds: Dataset, parent_ds: Dataset | None, children: Mapping[str, DataTree]) -> None - added:
method DataTree.assign(items: Mapping[Any, Any] | None=…, **items_kwargs: Any) -> DataTree - added:
method DataTree.chunk(chunks: T_ChunksFreq=…, name_prefix: str=…, token: str | None=…, lock: bool=…, inline_array: bool=…, chunked_array_type: str | ChunkManagerEntrypoint | None=…, from_array_kwargs=…, **chunks_kwargs: T_ChunkDimFreq) -> Self - added:
method DataTree.close() -> None - added:
method DataTree.compute(**kwargs) -> Self - added:
method DataTree.drop_nodes(names: str | Iterable[str], *, errors: ErrorOptions=…) -> DataTree - added:
method DataTree.equals(other: DataTree) -> bool - added:
method DataTree.filter(filterfunc: Callable[[DataTree], bool]) -> DataTree - added:
method DataTree.get(key: str, default: DataTree | DataArray | None=…) -> DataTree | DataArray | None - added:
method DataTree.identical(other: DataTree) -> bool - added:
method DataTree.isel(indexers: Mapping[Any, Any] | None=…, drop: bool=…, missing_dims: ErrorOptionsWithWarn=…, **indexers_kwargs: Any) -> Self - added:
method DataTree.isomorphic(other: DataTree) -> bool - added:
method DataTree.load(**kwargs) -> Self - added:
method DataTree.map_over_datasets(func: Callable, *args: Any) -> DataTree | tuple[DataTree, ...] - added:
method DataTree.match(pattern: str) -> DataTree - added:
method DataTree.persist(**kwargs) -> Self - added:
method DataTree.pipe(func: Callable | tuple[Callable, str], *args: Any, **kwargs: Any) -> Any - added:
method DataTree.reduce(func: Callable, dim: Dims=…, *, keep_attrs: bool | None=…, keepdims: bool=…, numeric_only: bool=…, **kwargs: Any) -> Self - added:
method DataTree.sel(indexers: Mapping[Any, Any] | None=…, method: str | None=…, tolerance: int | float | Iterable[int | float] | None=…, drop: bool=…, **indexers_kwargs: Any) -> Self - added:
method DataTree.set_close(close: Callable[[], None] | None) -> None - added:
method DataTree.to_dataset(inherit: bool=…) -> Dataset - added:
method DataTree.to_dict(relative: bool=…) -> dict[str, Dataset] - added:
method DataTree.to_netcdf(filepath, mode: NetcdfWriteModes=…, encoding=…, unlimited_dims=…, format: T_DataTreeNetcdfTypes | None=…, engine: T_DataTreeNetcdfEngine | None=…, group: str | None=…, write_inherited_coords: bool=…, compute: bool=…, **kwargs) - added:
method DataTree.to_zarr(store, mode: ZarrWriteModes=…, encoding=…, consolidated: bool=…, group: str | None=…, write_inherited_coords: bool=…, compute: Literal[True]=…, **kwargs) - added:
method DataTree.update(other: Dataset) -> None | (other: Mapping[Hashable, DataArray | Variable]) -> None | (other: Mapping[str, DataTree | DataArray | Variable]) -> None - added:
method DatasetView.close() -> None - added:
method DatasetView.map(func: Callable, keep_attrs: bool | None=…, args: Iterable[Any]=…, **kwargs: Any) -> Dataset - added:
method DatasetView.set_close(close: Callable[[], None] | None) -> None - added:
method DatasetView.update(other) -> NoReturn - added:
property DataTree.attrs -> dict[Hashable, Any] - added:
property DataTree.chunksizes -> Mapping[str, Mapping[Hashable, tuple[int, ...]]] - added:
property DataTree.coords -> DataTreeCoordinates - added:
property DataTree.data_vars -> DataVariables - added:
property DataTree.dataset -> DatasetView - added:
property DataTree.dims -> Mapping[Hashable, int] - added:
property DataTree.encoding -> dict - added:
property DataTree.groups - added:
property DataTree.has_attrs -> bool - added:
property DataTree.has_data -> bool - added:
property DataTree.indexes -> Indexes[pd.Index] - added:
property DataTree.is_empty -> bool - added:
property DataTree.is_hollow -> bool - added:
property DataTree.nbytes -> int - added:
property DataTree.sizes -> Mapping[Hashable, int] - added:
property DataTree.variables -> Mapping[Hashable, Variable] - added:
property DataTree.xindexes -> Indexes[Index] - added:
static method DataTree.from_dict(d: Mapping[str, Dataset | DataTree | None], /, name: str | None=…) -> Self - added:
variable T_Path
- added:
variable T_DataTreeNetcdfEngine - added:
variable T_DataTreeNetcdfTypes
- added:
function add_note(err: BaseException, msg: str) -> None - added:
function map_over_datasets(func: Callable[..., Dataset | None], *args: Any) -> DataTree | (func: Callable[..., tuple[Dataset | None, Dataset | None]], *args: Any) -> tuple[DataTree, DataTree] | (func: Callable[..., tuple[Dataset | None, ...]], *args: Any) -> tuple[DataTree, ...]
- added:
class AbstractStyle - added:
class ContStyle(AbstractStyle) - added:
class RenderDataTree - added:
constructor AbstractStyle(vertical: str, cont: str, end: str) - added:
constructor ContStyle() - added:
constructor RenderDataTree(node: DataTree, style=…, childiter: type=…, maxlevel: int | None=…) - added:
method RenderDataTree.by_attr(attrname: str=…) -> str - added:
property AbstractStyle.empty -> str - added:
variable Row
- changed:
function is_datetime_like(dtype) → function is_datetime_like(dtype) -> bool - changed:
function result_type(*arrays_and_dtypes: np.typing.ArrayLike | np.typing.DTypeLike) -> np.dtype → function result_type(*arrays_and_dtypes: np.typing.ArrayLike | np.typing.DTypeLike, xp=…) -> np.dtype - added:
function is_object(dtype) -> bool - added:
function is_string(dtype) -> bool - added:
function isdtype(dtype, kind: str | tuple[str, ...], xp=…) -> bool - added:
function preprocess_types(t)
- changed:
function asarray(data, xp=…) → function asarray(data, xp=…, dtype=…) - changed:
function get_array_namespace(x) → function get_array_namespace(*values) - changed:
function push(array, n, axis) → function push(array, n, axis, method=…) - added:
function round(array) - added:
variable around: Callable - added:
variable sliding_window_view
- added:
class PandasExtensionArray(Generic[T_ExtensionArray]) - added:
constructor PandasExtensionArray(array: T_ExtensionArray) - added:
field PandasExtensionArray.array: T_ExtensionArray - added:
function implements(numpy_function) - added:
variable HANDLED_EXTENSION_ARRAY_FUNCTIONS: dict[Callable, Callable]
- added:
function register_datatree_accessor(name)
- changed:
function diff_dim_summary(a, b) → function diff_dim_summary(a, b) -> str - changed:
function dim_summary_limited(obj, col_width: int, max_rows: int | None=…) -> str → function dim_summary_limited(sizes: Mapping[Any, int], col_width: int, max_rows: int | None=…) -> str - changed:
function indexes_repr(indexes, max_rows: int | None=…) -> str → function indexes_repr(indexes, max_rows: int | None=…, title: str=…) -> str - changed:
function summarize_variable(name: Hashable, var, col_width: int, max_width: int | None=…, is_index: bool=…) → function summarize_variable(name: Hashable, var: Variable, col_width: int, max_width: int | None=…, is_index: bool=…) - added:
function datatree_repr(dt: DataTree) -> str - added:
function diff_datatree_repr(a: DataTree, b: DataTree, compat) - added:
function diff_name_summary(a, b) -> str - added:
function diff_nodewise_summary(a: DataTree, b: DataTree, compat) - added:
function diff_treestructure(a: DataTree, b: DataTree) -> str | None - added:
function dims_and_coords_repr(ds) -> str - added:
function inherited_coords_repr(node: DataTree, col_width=…, max_rows=…) - added:
function inherited_vars(mapping: ChainMap) -> dict - added:
function render_human_readable_nbytes(nbytes: int, /, *, attempt_constant_width: bool=…) -> str - added:
variable UNITS
- added:
function datatree_node_repr(group_title: str, node: DataTree, show_inherited=…) -> str - added:
function datatree_repr(dt: DataTree) -> str - added:
function summarize_datatree_children(children: Mapping[str, DataTree]) -> str - added:
variable children_section - added:
variable inherited_coord_section
- removed:
class BinGrouper(Grouper) - removed:
class Grouper(ABC) - removed:
class ResolvedBinGrouper(ResolvedGrouper) - removed:
class ResolvedTimeResampleGrouper(ResolvedGrouper) - removed:
class ResolvedUniqueGrouper(ResolvedGrouper) - removed:
class TimeResampleGrouper(Grouper) - removed:
class UniqueGrouper(Grouper) - removed:
field BinGrouper.bins: Any - removed:
field BinGrouper.cut_kwargs: Mapping - removed:
field ResolvedBinGrouper.grouper: BinGrouper - removed:
field ResolvedGrouper.codes: DataArray - removed:
field ResolvedGrouper.full_index: pd.Index - removed:
field ResolvedGrouper.group1d: T_Group - removed:
field ResolvedGrouper.group_indices: T_GroupIndices - removed:
field ResolvedGrouper.inserted_dims: list[Hashable] - removed:
field ResolvedGrouper.stacked_dim: Hashable | None - removed:
field ResolvedGrouper.stacked_obj: T_Xarray - removed:
field ResolvedGrouper.unique_coord: IndexVariable | _DummyGroup - removed:
field ResolvedTimeResampleGrouper.grouper: TimeResampleGrouper - removed:
field ResolvedTimeResampleGrouper.index_grouper: CFTimeGrouper | pd.Grouper - removed:
field ResolvedUniqueGrouper.grouper: UniqueGrouper - removed:
field TimeResampleGrouper.closed: SideOptions | None - removed:
field TimeResampleGrouper.freq: str - removed:
field TimeResampleGrouper.label: SideOptions | None - removed:
field TimeResampleGrouper.loffset: datetime.timedelta | str | None - removed:
field TimeResampleGrouper.offset: pd.Timedelta | datetime.timedelta | str | None - removed:
field TimeResampleGrouper.origin: str | DatetimeLike | None - removed:
function unique_value_groups(ar, sort: bool=…) -> tuple[np.ndarray | pd.Index, T_GroupIndices, np.ndarray] - removed:
method ResolvedGrouper.factorize(squeeze: bool) -> None - removed:
method ResolvedTimeResampleGrouper.first_items() -> tuple[pd.Series, np.ndarray] - removed:
property ResolvedGrouper.dims - removed:
property ResolvedGrouper.group_as_index -> pd.Index - removed:
property ResolvedGrouper.is_unique_and_monotonic -> bool - removed:
variable GroupIndex - removed:
variable GroupKey - removed:
variable T_FactorizeOut - removed:
variable T_GroupIndices - changed:
class ResolvedGrouper(ABC, Generic[T_Xarray]) → class ResolvedGrouper(Generic[T_DataWithCoords]) - changed:
constructor GroupBy(obj: T_Xarray, groupers: tuple[ResolvedGrouper], squeeze: bool=…, restore_coord_dims: bool=…) -> None → constructor GroupBy(obj: T_Xarray, groupers: tuple[ResolvedGrouper, ...], restore_coord_dims: bool=…) -> None - changed:
field GroupBy.groupers: tuple[ResolvedGrouper] → field GroupBy.groupers: tuple[ResolvedGrouper, ...] - changed:
field ResolvedGrouper.obj: T_Xarray → field ResolvedGrouper.obj: T_DataWithCoords - added:
class ComposedGrouper - added:
field ComposedGrouper.groupers: tuple[ResolvedGrouper, ...] - added:
field GroupBy.encoded: EncodedGroups - added:
field GroupBy.group1d: T_Group - added:
field ResolvedGrouper.eagerly_compute_group: bool - added:
field ResolvedGrouper.encoded: EncodedGroups - added:
method ComposedGrouper.factorize() -> EncodedGroups - added:
method GroupBy.shuffle_to_chunks(chunks: T_Chunks=…) -> T_Xarray - added:
property ResolvedGrouper.codes -> DataArray - added:
property ResolvedGrouper.full_index -> pd.Index - added:
property ResolvedGrouper.unique_coord -> Variable | _DummyGroup
- changed:
constructor PandasIndex(array: Any, dim: Hashable, coord_dtype: Any=…) → constructor PandasIndex(array: Any, dim: Hashable, coord_dtype: Any=…, *, fastpath: bool=…) - changed:
function get_indexer_nd(index, labels, method=…, tolerance=…) → function get_indexer_nd(index: pd.Index, labels, method=…, tolerance=…) -> np.ndarray - changed:
function remove_unused_levels_categories(index: pd.Index) -> pd.Index → function remove_unused_levels_categories(index: T_PDIndex) -> T_PDIndex - added:
field PandasMultiIndex.coord_dtype: Any - added:
field PandasMultiIndex.dim: Hashable - added:
field PandasMultiIndex.index: pd.MultiIndex - added:
variable T_PDIndex
- removed:
property ExplicitIndexer.tuple - removed:
property LazilyIndexedArray.shape -> tuple[int, ...] - removed:
property LazilyVectorizedIndexedArray.shape -> tuple[int, ...] - removed:
property PandasIndexingAdapter.shape -> tuple[int, ...] - changed:
constructor BasicIndexer(key) → constructor BasicIndexer(key: tuple[int | np.integer | slice, ...]) - changed:
constructor CopyOnWriteArray(array) → constructor CopyOnWriteArray(array: duckarray[Any, Any]) - changed:
constructor ExplicitIndexer(key) → constructor ExplicitIndexer(key: tuple[Any, ...]) - changed:
constructor ImplicitToExplicitIndexingAdapter(array, indexer_cls=…) → constructor ImplicitToExplicitIndexingAdapter(array, indexer_cls: type[ExplicitIndexer]=…) - changed:
constructor LazilyIndexedArray(array, key=…) → constructor LazilyIndexedArray(array: Any, key: ExplicitIndexer | None=…) - changed:
constructor LazilyVectorizedIndexedArray(array, key) → constructor LazilyVectorizedIndexedArray(array: duckarray[Any, Any], key: ExplicitIndexer) - changed:
constructor OuterIndexer(key) → constructor OuterIndexer(key: tuple[int | np.integer | slice | np.ndarray[Any, np.dtype[np.generic]], ...]) - changed:
constructor VectorizedIndexer(key) → constructor VectorizedIndexer(key: tuple[slice | np.ndarray[Any, np.dtype[np.generic]], ...]) - changed:
function as_integer_or_none(value) → function as_integer_or_none(value: int) -> int | (value: None) -> None - changed:
function as_integer_slice(value) → function as_integer_slice(value: slice) -> slice - changed:
function create_mask(indexer, shape, data=…) → function create_mask(indexer: ExplicitIndexer, shape: _Shape, data: duckarray[Any, Any] | None=…) - changed:
function decompose_indexer(indexer: ExplicitIndexer, shape: tuple[int, ...], indexing_support: IndexingSupport) -> tuple[ExplicitIndexer, ExplicitIndexer] → function decompose_indexer(indexer: ExplicitIndexer, shape: _Shape, indexing_support: IndexingSupport) -> tuple[ExplicitIndexer, ExplicitIndexer] - changed:
function explicit_indexing_adapter(key: ExplicitIndexer, shape: tuple[int, ...], indexing_support: IndexingSupport, raw_indexing_method: Callable) -> Any → function explicit_indexing_adapter(key: ExplicitIndexer, shape: _Shape, indexing_support: IndexingSupport, raw_indexing_method: Callable[..., Any]) -> Any - changed:
function map_index_queries(obj: T_Xarray, indexers: Mapping[Any, Any], method=…, tolerance=…, **indexers_kwargs: Any) -> IndexSelResult → function map_index_queries(obj: T_Xarray, indexers: Mapping[Any, Any], method=…, tolerance: int | float | Iterable[int | float] | None=…, **indexers_kwargs: Any) -> IndexSelResult - changed:
function posify_mask_indexer(indexer) → function posify_mask_indexer(indexer: ExplicitIndexer) -> ExplicitIndexer - changed:
function slice_slice(old_slice, applied_slice, size) → function slice_slice(old_slice: slice, applied_slice: slice, size: int) -> slice - changed:
method PandasIndexingAdapter.copy(deep: bool=…) -> PandasIndexingAdapter → method PandasIndexingAdapter.copy(deep: bool=…) -> Self - changed:
method PandasMultiIndexingAdapter.copy(deep: bool=…) -> PandasMultiIndexingAdapter → method PandasMultiIndexingAdapter.copy(deep: bool=…) -> Self - added:
class IndexCallable - added:
constructor IndexCallable(getter: Callable[..., Any], setter: Callable[..., Any] | None=…) - added:
field PandasIndexingAdapter.array: pd.Index - added:
field PandasMultiIndexingAdapter.array: pd.MultiIndex - added:
field PandasMultiIndexingAdapter.level: str | None - added:
function apply_indexer(indexable, indexer: ExplicitIndexer) - added:
function set_with_indexer(indexable, indexer: ExplicitIndexer, value: Any) -> None - added:
property ExplicitIndexer.tuple -> tuple[Any, ...] - added:
property ExplicitlyIndexedNDArrayMixin.oindex -> IndexCallable - added:
property ExplicitlyIndexedNDArrayMixin.vindex -> IndexCallable - added:
property LazilyIndexedArray.shape -> _Shape - added:
property LazilyVectorizedIndexedArray.shape -> _Shape - added:
property PandasIndexingAdapter.shape -> _Shape
- removed:
function assert_valid_explicit_coords(variables: Mapping[Any, Any], dims: Mapping[Any, int], explicit_coords: Iterable[Hashable]) -> None
- changed:
constructor ScipyInterpolator(xi, yi, method=…, fill_value=…, assume_sorted=…, copy=…, bounds_error=…, order=…, **kwargs) → constructor ScipyInterpolator(xi, yi, method=…, fill_value=…, assume_sorted=…, copy=…, bounds_error=…, order=…, axis=…, **kwargs) - changed:
function get_clean_interp_index(arr, dim: Hashable, use_coordinate: str | bool=…, strict: bool=…) → function get_clean_interp_index(arr, dim: Hashable, use_coordinate: Hashable | bool=…, strict: bool=…) - changed:
function interp_na(self, dim: Hashable | None=…, use_coordinate: bool | str=…, method: InterpOptions=…, limit: int | None=…, max_gap: int | float | str | pd.Timedelta | np.timedelta64 | dt.timedelta=…, keep_attrs: bool | None=…, **kwargs) → function interp_na(self, dim: Hashable | None=…, use_coordinate: bool | str=…, method: InterpOptions=…, limit: int | None=…, max_gap: int | float | str | pd.Timedelta | np.timedelta64 | dt.timedelta | None=…, keep_attrs: bool | None=…, **kwargs)
- added:
function isdtype(dtype: np.dtype[Any] | type[Any], kind: DTypeLike | tuple[DTypeLike, ...]) -> bool - added:
variable HAS_STRING_DTYPE - added:
variable kind_mapping
- added:
variable nanquantile
- added:
field T_Options.arithmetic_broadcast: bool - added:
field T_Options.chunk_manager: str - added:
field T_Options.display_expand_groups: Literal['default', True, False]
- changed:
function check_result_variables(result: DataArray | Dataset, expected: Mapping[str, Any], kind: str) → function check_result_variables(result: DataArray | Dataset, expected: ExpectedDict, kind: Literal['coords', 'data_vars']) - added:
class ExpectedDict(TypedDict) - added:
field ExpectedDict.coords: set[Hashable] - added:
field ExpectedDict.data_vars: set[Hashable] - added:
field ExpectedDict.shapes: dict[Hashable, int] - added:
function subset_dataset_to_block(graph: dict, gname: str, dataset: Dataset, input_chunk_bounds, chunk_index)
- removed:
class ChunkManagerEntrypoint(ABC, Generic[T_ChunkedArray]) - removed:
constructor ChunkManagerEntrypoint() -> None - removed:
field ChunkManagerEntrypoint.array_cls: type[T_ChunkedArray] - removed:
field ChunkManagerEntrypoint.available: bool - removed:
function get_chunked_array_type(*args) -> ChunkManagerEntrypoint - removed:
function guess_chunkmanager(manager: str | ChunkManagerEntrypoint | None) -> ChunkManagerEntrypoint - removed:
function list_chunkmanagers() -> dict[str, ChunkManagerEntrypoint] - removed:
function load_chunkmanagers(entrypoints: Sequence[EntryPoint]) -> dict[str, ChunkManagerEntrypoint] - removed:
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) - removed:
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) - removed:
method ChunkManagerEntrypoint.chunks(data: T_ChunkedArray) -> T_NormalizedChunks - removed:
method ChunkManagerEntrypoint.compute(*data: T_ChunkedArray | Any, **kwargs) -> tuple[np.ndarray, ...] - removed:
method ChunkManagerEntrypoint.from_array(data: T_DuckArray | np.typing.ArrayLike, chunks: T_Chunks, **kwargs) -> T_ChunkedArray - removed:
method ChunkManagerEntrypoint.is_chunked_array(data: Any) -> bool - removed:
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) - removed:
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 - removed:
method ChunkManagerEntrypoint.rechunk(data: T_ChunkedArray, chunks: T_NormalizedChunks | tuple[int, ...] | T_Chunks, **kwargs) -> T_ChunkedArray - removed:
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 - removed:
method ChunkManagerEntrypoint.store(sources: T_ChunkedArray | Sequence[T_ChunkedArray], targets: Any, **kwargs: dict[str, Any]) - removed:
method ChunkManagerEntrypoint.unify_chunks(*args: Any, **kwargs) -> tuple[dict[str, T_NormalizedChunks], list[T_ChunkedArray]] - removed:
property ChunkManagerEntrypoint.array_api -> Any - removed:
variable T_ChunkedArray
- removed:
class DuckArrayModule - removed:
constructor DuckArrayModule(mod: ModType) -> None - removed:
field DuckArrayModule.available: bool - removed:
field DuckArrayModule.module: ModuleType | None - removed:
field DuckArrayModule.type: DuckArrayTypes - removed:
field DuckArrayModule.version: Version - removed:
function array_type(mod: ModType) -> DuckArrayTypes - removed:
function is_0d_dask_array(x) - removed:
function is_chunked_array(x) -> bool - removed:
function is_dask_collection(x) - removed:
function is_duck_dask_array(x) - removed:
function mod_version(mod: ModType) -> Version - removed:
function to_duck_array(data) - removed:
function to_numpy(data) -> np.ndarray - removed:
variable DuckArrayTypes - removed:
variable ModType - removed:
variable integer_types
- removed:
variable RESAMPLE_DIM - changed:
method Resample.backfill(tolerance: float | Iterable[float] | None=…) -> T_Xarray → method Resample.backfill(tolerance: float | Iterable[float] | str | None=…) -> T_Xarray - changed:
method Resample.interpolate(kind: InterpOptions=…) -> T_Xarray → method Resample.interpolate(kind: InterpOptions=…, **kwargs) -> T_Xarray - changed:
method Resample.nearest(tolerance: float | Iterable[float] | None=…) -> T_Xarray → method Resample.nearest(tolerance: float | Iterable[float] | str | None=…) -> T_Xarray - changed:
method Resample.pad(tolerance: float | Iterable[float] | None=…) -> T_Xarray → method Resample.pad(tolerance: float | Iterable[float] | str | None=…) -> T_Xarray - added:
method DataArrayResample.reduce(func: Callable[..., Any], dim: Dims=…, *, axis: int | Sequence[int] | None=…, keep_attrs: bool | None=…, keepdims: bool=…, shortcut: bool=…, **kwargs: Any) -> DataArray - added:
method Resample.shuffle_to_chunks(chunks: T_Chunks=…)
- changed:
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=…) → constructor CFTimeGrouper(freq: ResampleCompatible | BaseCFTimeOffset, closed: SideOptions | None=…, label: SideOptions | None=…, origin: str | CFTimeDatetime=…, offset: str | datetime.timedelta | BaseCFTimeOffset | None=…) - added:
field CFTimeGrouper.closed: SideOptions - added:
field CFTimeGrouper.freq: BaseCFTimeOffset - added:
field CFTimeGrouper.label: SideOptions - added:
field CFTimeGrouper.loffset: str | datetime.timedelta | BaseCFTimeOffset | None - added:
field CFTimeGrouper.offset: datetime.timedelta | None - added:
field CFTimeGrouper.origin: str | CFTimeDatetime
- changed:
method DataArrayRolling.construct(window_dim: Hashable | Mapping[Any, Hashable] | None=…, stride: int | Mapping[Any, int]=…, fill_value: Any=…, keep_attrs: bool | None=…, **window_dim_kwargs: Hashable) -> DataArray → method DataArrayRolling.construct(window_dim: Hashable | Mapping[Any, Hashable] | None=…, *, stride: int | Mapping[Any, int]=…, fill_value: Any=…, keep_attrs: bool | None=…, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **window_dim_kwargs: Hashable) -> DataArray - changed:
method DataArrayRolling.reduce(func: Callable, keep_attrs: bool | None=…, **kwargs: Any) -> DataArray → method DataArrayRolling.reduce(func: Callable, keep_attrs: bool | None=…, *, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **kwargs: Any) -> DataArray - changed:
method DatasetRolling.construct(window_dim: Hashable | Mapping[Any, Hashable] | None=…, stride: int | Mapping[Any, int]=…, fill_value: Any=…, keep_attrs: bool | None=…, **window_dim_kwargs: Hashable) -> Dataset → method DatasetRolling.construct(window_dim: Hashable | Mapping[Any, Hashable] | None=…, *, stride: int | Mapping[Any, int]=…, fill_value: Any=…, keep_attrs: bool | None=…, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **window_dim_kwargs: Hashable) -> Dataset - changed:
method DatasetRolling.reduce(func: Callable, keep_attrs: bool | None=…, **kwargs: Any) -> DataArray → method DatasetRolling.reduce(func: Callable, keep_attrs: bool | None=…, sliding_window_view_kwargs: Mapping[Any, Any] | None=…, **kwargs: Any) -> DataArray
- added:
class InvalidTreeError(Exception) - added:
class NamedNode(TreeNode, Generic[Tree]) - added:
class NodePath(PurePosixPath) - added:
class NotFoundInTreeError(ValueError) - added:
class TreeIsomorphismError(ValueError) - added:
class TreeNode(Generic[Tree]) - added:
constructor NamedNode(name=…, children=…) - added:
constructor NodePath(*pathsegments) - added:
constructor TreeNode(children: Mapping[str, Tree] | None=…) - added:
function group_subtrees(*trees: AnyNamedNode) -> Iterator[tuple[str, tuple[AnyNamedNode, ...]]] - added:
function zip_subtrees(*trees: AnyNamedNode) -> Iterator[tuple[AnyNamedNode, ...]] - added:
method NamedNode.find_common_ancestor(other: NamedNode) -> NamedNode - added:
method NamedNode.relative_to(other: NamedNode) -> str - added:
method TreeNode.copy(*, inherit: bool=…, deep: bool=…) -> Self - added:
method TreeNode.get(key: str, default: Tree | None=…) -> Tree | None - added:
method TreeNode.iter_lineage() -> tuple[Tree, ...] - added:
method TreeNode.orphan() -> None - added:
method TreeNode.same_tree(other: Tree) -> bool - added:
property NamedNode.name -> str | None - added:
property NamedNode.path -> str - added:
property TreeNode.ancestors -> tuple[Tree, ...] - added:
property TreeNode.children -> Mapping[str, Tree] - added:
property TreeNode.depth -> int - added:
property TreeNode.descendants -> tuple[Tree, ...] - added:
property TreeNode.is_leaf -> bool - added:
property TreeNode.is_root -> bool - added:
property TreeNode.leaves -> tuple[Tree, ...] - added:
property TreeNode.level -> int - added:
property TreeNode.lineage -> tuple[Tree, ...] - added:
property TreeNode.parent -> Tree | None - added:
property TreeNode.parents -> tuple[Tree, ...] - added:
property TreeNode.root -> Tree - added:
property TreeNode.siblings -> dict[str, Tree] - added:
property TreeNode.subtree -> Iterator[Tree] - added:
property TreeNode.subtree_with_keys -> Iterator[tuple[str, Tree]] - added:
property TreeNode.width -> int - added:
variable AnyNamedNode - added:
variable Tree
- removed:
variable NestedSequence - removed:
variable OrderedDims - changed:
variable DatetimeLike → variable DatetimeLike: TypeAlias - added:
class BaseBuffer(Protocol) - added:
class NestedSequence(Protocol[_T_co]) - added:
class ReadBuffer(BaseBuffer, Protocol[AnyStr_co]) - added:
method BaseBuffer.seek(__offset: int, __whence: int=…) -> int - added:
method BaseBuffer.seekable() -> bool - added:
method BaseBuffer.tell() -> int - added:
method ReadBuffer.read(__n: int=…) -> AnyStr_co - added:
property BaseBuffer.mode -> str - added:
variable AnyStr_co - added:
variable Bins - added:
variable DtCompatible - added:
variable GroupIndex - added:
variable GroupIndices - added:
variable GroupInput: TypeAlias - added:
variable GroupKey - added:
variable InterpnOptions - added:
variable NPDatetimeUnitOptions - added:
variable NetcdfWriteModes - added:
variable ResampleCompatible: TypeAlias - added:
variable T_ChunkDimFreq: TypeAlias - added:
variable T_ChunksFreq: TypeAlias - added:
variable T_DatasetPadConstantValues - added:
variable T_ExtensionArray - added:
variable T_PadConstantValues - added:
variable T_VarPadConstantValues
- removed:
class HybridMappingProxy(Mapping[K, V]) - removed:
class ReprObject - removed:
constructor HybridMappingProxy(keys: Collection[K], mapping: Mapping[K, V]) - removed:
constructor ReprObject(value: str) - removed:
function drop_missing_dims(supplied_dims: Iterable[Hashable], dims: Iterable[Hashable], missing_dims: ErrorOptionsWithWarn) -> Iterable[Hashable] - removed:
function either_dict_or_kwargs(pos_kwargs: Mapping[Any, T] | None, kw_kwargs: Mapping[str, T], func_name: str) -> Mapping[Hashable, T] - removed:
function infix_dims(dims_supplied: Collection, dims_all: Collection, missing_dims: ErrorOptionsWithWarn=…) -> Iterator - removed:
function is_dict_like(value: Any) -> TypeGuard[Mapping] - removed:
function is_duck_array(value: Any) -> TypeGuard[T_DuckArray] - removed:
function module_available(module: str) -> bool - removed:
function parse_dims(dim: str | Iterable[Hashable] | T_None, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[True]=…) -> tuple[Hashable, ...] | (dim: str | Iterable[Hashable] | T_None, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[False]) -> tuple[Hashable, ...] | T_None - removed:
function to_0d_object_array(value: Any) -> np.ndarray - removed:
variable T_None - changed:
function consolidate_dask_from_array_kwargs(from_array_kwargs: dict, name: str | None=…, lock: bool | None=…, inline_array: bool | None=…) -> dict → function consolidate_dask_from_array_kwargs(from_array_kwargs: dict[Any, Any], name: str | None=…, lock: bool | None=…, inline_array: bool | None=…) -> dict[Any, Any] - changed:
function emit_user_level_warning(message, category=…) → function emit_user_level_warning(message, category=…) -> None - changed:
function get_valid_numpy_dtype(array: np.ndarray | pd.Index) → function get_valid_numpy_dtype(array: np.ndarray | pd.Index) -> np.dtype - changed:
function list_equiv(first, second) → function list_equiv(first: Sequence[T], second: Sequence[T]) -> bool - changed:
function parse_ordered_dims(dim: str | Sequence[Hashable | ellipsis] | T_None, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[True]=…) -> tuple[Hashable, ...] | (dim: str | Sequence[Hashable | ellipsis] | T_None, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[False]) -> tuple[Hashable, ...] | T_None → function parse_ordered_dims(dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[True]=…) -> tuple[Hashable, ...] | (dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[False]) -> tuple[Hashable, ...] | None | EllipsisType - added:
class FilteredMapping(Mapping[K, V]) - added:
constructor FilteredMapping(keys: Collection[K], mapping: Mapping[K, V]) - added:
function attempt_import(module: str) -> ModuleType - added:
function parse_dims_as_set(dim: Dims, all_dims: set[Hashable], *, check_exists: bool=…, replace_none: Literal[True]=…) -> set[Hashable] | (dim: Dims, all_dims: set[Hashable], *, check_exists: bool=…, replace_none: Literal[False]) -> set[Hashable] | None | EllipsisType - added:
function parse_dims_as_tuple(dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[True]=…) -> tuple[Hashable, ...] | (dim: Dims, all_dims: tuple[Hashable, ...], *, check_exists: bool=…, replace_none: Literal[False]) -> tuple[Hashable, ...] | None | EllipsisType - added:
function result_name(objects: Iterable[Any]) -> Any
- removed:
method Variable.as_numpy() -> Self - removed:
method Variable.to_numpy() -> np.ndarray - removed:
property Variable.values - changed:
function as_variable(obj: T_DuckArray | Any, name=…) -> Variable | IndexVariable → function as_variable(obj: T_DuckArray | Any, name=…, auto_convert: bool=…) -> Variable | IndexVariable - changed:
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 → method Variable.chunk(chunks: T_Chunks=…, name: str | None=…, lock: bool | None=…, inline_array: bool | None=…, chunked_array_type: str | ChunkManagerEntrypoint[Any] | None=…, from_array_kwargs: Any=…, **chunks_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=…, keep_attrs: bool |… → 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: T_VarPadConstantValues | None=…, end_values: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None=…, reflect_type: PadReflectOptions=…, keep_attrs: bool | None=…, **pad_width_kwargs: Any) - changed:
method Variable.rolling_window(dim, window, window_dim, center=…, fill_value=…) → method Variable.rolling_window(dim, window, window_dim, *, center=…, fill_value=…, **kwargs) - changed:
method Variable.set_dims(dims, shape=…) → method Variable.set_dims(dim, shape=…) - changed:
method Variable.stack(dimensions=…, **dimensions_kwargs) → method Variable.stack(dim=…, **dim_kwargs) - changed:
method Variable.transpose(*dims: Hashable | ellipsis, missing_dims: ErrorOptionsWithWarn=…) -> Self → method Variable.transpose(*dim: Hashable | EllipsisType, missing_dims: ErrorOptionsWithWarn=…) -> Self - changed:
method Variable.unstack(dimensions=…, **dimensions_kwargs) → method Variable.unstack(dim=…, **dim_kwargs) -> Variable - added:
property Variable.values -> np.ndarray
- changed:
constructor Weighted(obj: T_Xarray, weights: DataArray) -> None → constructor Weighted(obj: T_Xarray, weights: T_DataArray) -> None
- added:
class BinGrouper(Grouper) - added:
class EncodedGroups - added:
class Grouper(ABC) - added:
class Resampler(Grouper) - added:
class TimeResampler(Resampler) - added:
class UniqueGrouper(Grouper) - added:
constructor EncodedGroups(codes: DataArray, full_index: pd.Index, group_indices: GroupIndices | None=…, unique_coord: Variable | _DummyGroup | None=…, coords: Coordinates | None=…) - added:
field BinGrouper.bins: Bins - added:
field BinGrouper.duplicates: Literal['raise', 'drop'] - added:
field BinGrouper.include_lowest: bool - added:
field BinGrouper.labels: Any - added:
field BinGrouper.precision: int - added:
field BinGrouper.right: bool - added:
field EncodedGroups.codes: DataArray - added:
field EncodedGroups.coords: Coordinates - added:
field EncodedGroups.full_index: pd.Index - added:
field EncodedGroups.group_indices: GroupIndices - added:
field EncodedGroups.unique_coord: Variable | _DummyGroup - added:
field TimeResampler.closed: SideOptions | None - added:
field TimeResampler.freq: ResampleCompatible - added:
field TimeResampler.group_as_index: pd.Index - added:
field TimeResampler.index_grouper: CFTimeGrouper | pd.Grouper - added:
field TimeResampler.label: SideOptions | None - added:
field TimeResampler.offset: pd.Timedelta | datetime.timedelta | str | None - added:
field TimeResampler.origin: str | DatetimeLike - added:
field UniqueGrouper.labels: ArrayLike | None - added:
method BinGrouper.factorize(group: T_Group) -> EncodedGroups - added:
method BinGrouper.reset() -> Self - added:
method Grouper.factorize(group: T_Group) -> EncodedGroups - added:
method Grouper.reset() -> Self - added:
method TimeResampler.factorize(group: T_Group) -> EncodedGroups - added:
method TimeResampler.first_items() -> tuple[pd.Series, np.ndarray] - added:
method TimeResampler.reset() -> Self - added:
method UniqueGrouper.factorize(group: T_Group) -> EncodedGroups - added:
method UniqueGrouper.reset() -> Self - added:
property UniqueGrouper.group_as_index -> pd.Index
- changed:
method NamedArray.get_axis_num(dim: Hashable | Iterable[Hashable]) -> int | tuple[int, ...] → method NamedArray.get_axis_num(dim: Iterable[Hashable]) -> tuple[int, ...] | (dim: Hashable) -> int - added:
method NamedArray.as_numpy() -> Self - added:
method NamedArray.broadcast_to(dim: Mapping[_Dim, int] | None=…, **dim_kwargs: Any) -> NamedArray[Any, _DType_co] - added:
method NamedArray.chunk(chunks: T_Chunks=…, chunked_array_type: str | ChunkManagerEntrypoint[Any] | None=…, from_array_kwargs: Any=…, **chunks_kwargs: Any) -> Self - added:
method NamedArray.expand_dims(dim: _Dim | Default=…) -> NamedArray[Any, _DType_co] - added:
method NamedArray.permute_dims(*dim: Iterable[_Dim] | EllipsisType, missing_dims: ErrorOptionsWithWarn=…) -> NamedArray[Any, _DType_co] - added:
method NamedArray.to_numpy() -> np.ndarray[Any, Any] - added:
property NamedArray.T -> NamedArray[Any, _DType_co]
- 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[..., Any], signature: str, *args: Any, axes: Sequence[tuple[int, ...]] | None=…, axis: int | None=…, keepdims: bool=…, output_dtypes: Sequence[_DType_co] | None=…, output_sizes: dict[str, int] | None=…, vectorize: bool | None=…, allow_rechunk: bool=…, meta: tuple[np.ndarray[Any, _DType_co], ...] | None=…, **kwargs: Any) -> Any - added:
method DaskManager.blockwise(func: Callable[..., Any], out_ind: Iterable[Any], *args: Any, name: str | None=…, token: Any | None=…, dtype: _DType_co | None=…, adjust_chunks: dict[Any, Callable[..., Any]] | None=…, new_axes: dict[Any, int] | None=…, align_arrays: bool=…, concatenate: bool | None=…, meta: tuple[np.ndarray[Any, _DType_co], ...] | None=…, **kwargs: Any) -> DaskArray | Any - added:
method DaskManager.chunks(data: Any) -> _NormalizedChunks - added:
method DaskManager.compute(*data: Any, **kwargs: Any) -> tuple[np.ndarray[Any, _DType_co], ...] - added:
method DaskManager.from_array(data: Any, chunks: T_Chunks | _NormalizedChunks, **kwargs: Any) -> DaskArray | Any - added:
method DaskManager.is_chunked_array(data: duckarray[Any, Any]) -> bool - added:
method DaskManager.map_blocks(func: Callable[..., Any], *args: Any, dtype: _DType_co | None=…, chunks: tuple[int, ...] | None=…, drop_axis: int | Sequence[int] | None=…, new_axis: int | Sequence[int] | None=…, **kwargs: Any) -> Any - added:
method DaskManager.normalize_chunks(chunks: T_Chunks | _NormalizedChunks, shape: tuple[int, ...] | None=…, limit: int | None=…, dtype: _DType_co | None=…, previous_chunks: _NormalizedChunks | None=…) -> Any - added:
method DaskManager.persist(*data: Any, **kwargs: Any) -> tuple[DaskArray | Any, ...] - added:
method DaskManager.reduction(arr: T_ChunkedArray, func: Callable[..., Any], combine_func: Callable[..., Any] | None=…, aggregate_func: Callable[..., Any] | None=…, axis: int | Sequence[int] | None=…, dtype: _DType_co | None=…, keepdims: bool=…) -> DaskArray | Any - added:
method DaskManager.scan(func: Callable[..., Any], binop: Callable[..., Any], ident: float, arr: T_ChunkedArray, axis: int | None=…, dtype: _DType_co | None=…, **kwargs: Any) -> DaskArray | Any - added:
method DaskManager.shuffle(x: DaskArray, indexer: list[list[int]], axis: int, chunks: T_Chunks) -> DaskArray - added:
method DaskManager.store(sources: Any | Sequence[Any], targets: Any, **kwargs: Any) -> Any - added:
method DaskManager.unify_chunks(*args: Any, **kwargs: Any) -> tuple[dict[str, _NormalizedChunks], list[DaskArray]] - added:
property DaskManager.array_api -> Any - added:
variable DaskArray - added:
variable dask_available
- added:
class ChunkManagerEntrypoint(ABC, Generic[T_ChunkedArray]) - added:
class ChunkedArrayMixinProtocol(Protocol) - added:
constructor ChunkManagerEntrypoint() -> None - added:
field ChunkManagerEntrypoint.array_cls: type[T_ChunkedArray] - added:
field ChunkManagerEntrypoint.available: bool - added:
function get_chunked_array_type(*args: Any) -> ChunkManagerEntrypoint[Any] - added:
function guess_chunkmanager(manager: str | ChunkManagerEntrypoint[Any] | None) -> ChunkManagerEntrypoint[Any] - added:
function list_chunkmanagers() -> dict[str, ChunkManagerEntrypoint[Any]] - added:
function load_chunkmanagers(entrypoints: Sequence[EntryPoint]) -> dict[str, ChunkManagerEntrypoint[Any]] - added:
method ChunkManagerEntrypoint.apply_gufunc(func: Callable[..., Any], signature: str, *args: Any, axes: Sequence[tuple[int, ...]] | None=…, keepdims: bool=…, output_dtypes: Sequence[_DType_co] | None=…, vectorize: bool | None=…, **kwargs: Any) -> Any - added:
method ChunkManagerEntrypoint.blockwise(func: Callable[..., Any], out_ind: Iterable[Any], *args: Any, adjust_chunks: dict[Any, Callable[..., Any]] | None=…, new_axes: dict[Any, int] | None=…, align_arrays: bool=…, **kwargs: Any) -> Any - added:
method ChunkManagerEntrypoint.chunks(data: T_ChunkedArray) -> _NormalizedChunks - added:
method ChunkManagerEntrypoint.compute(*data: T_ChunkedArray | Any, **kwargs: Any) -> tuple[np.ndarray[Any, _DType_co], ...] - added:
method ChunkManagerEntrypoint.from_array(data: duckarray[Any, Any], chunks: _Chunks, **kwargs: Any) -> T_ChunkedArray - added:
method ChunkManagerEntrypoint.is_chunked_array(data: duckarray[Any, Any]) -> bool - added:
method ChunkManagerEntrypoint.map_blocks(func: Callable[..., Any], *args: Any, dtype: _DType_co | None=…, chunks: tuple[int, ...] | None=…, drop_axis: int | Sequence[int] | None=…, new_axis: int | Sequence[int] | None=…, **kwargs: Any) -> Any - added:
method ChunkManagerEntrypoint.normalize_chunks(chunks: _Chunks | _NormalizedChunks, shape: _ShapeType | None=…, limit: int | None=…, dtype: _DType | None=…, previous_chunks: _NormalizedChunks | None=…) -> _NormalizedChunks - added:
method ChunkManagerEntrypoint.persist(*data: T_ChunkedArray | Any, **kwargs: Any) -> tuple[T_ChunkedArray | Any, ...] - added:
method ChunkManagerEntrypoint.rechunk(data: T_ChunkedArray, chunks: _NormalizedChunks | tuple[int, ...] | _Chunks, **kwargs: Any) -> Any - added:
method ChunkManagerEntrypoint.reduction(arr: T_ChunkedArray, func: Callable[..., Any], combine_func: Callable[..., Any] | None=…, aggregate_func: Callable[..., Any] | None=…, axis: int | Sequence[int] | None=…, dtype: _DType_co | None=…, keepdims: bool=…) -> T_ChunkedArray - added:
method ChunkManagerEntrypoint.scan(func: Callable[..., Any], binop: Callable[..., Any], ident: float, arr: T_ChunkedArray, axis: int | None=…, dtype: _DType_co | None=…, **kwargs: Any) -> T_ChunkedArray - added:
method ChunkManagerEntrypoint.shuffle(x: T_ChunkedArray, indexer: list[list[int]], axis: int, chunks: T_Chunks) -> T_ChunkedArray - added:
method ChunkManagerEntrypoint.store(sources: T_ChunkedArray | Sequence[T_ChunkedArray], targets: Any, **kwargs: dict[str, Any]) -> Any - added:
method ChunkManagerEntrypoint.unify_chunks(*args: Any, **kwargs: Any) -> tuple[dict[str, _NormalizedChunks], list[T_ChunkedArray]] - added:
method ChunkedArrayMixinProtocol.compute(*data: Any, **kwargs: Any) -> tuple[np.ndarray[Any, _DType_co], ...] - added:
method ChunkedArrayMixinProtocol.rechunk(chunks: Any, **kwargs: Any) -> Any - added:
property ChunkManagerEntrypoint.array_api -> Any - added:
property ChunkedArrayMixinProtocol.chunks -> _NormalizedChunks - added:
property ChunkedArrayMixinProtocol.dtype -> np.dtype[Any] - added:
variable T_ChunkedArray
- added:
class DuckArrayModule - added:
constructor DuckArrayModule(mod: ModType) -> None - added:
field DuckArrayModule.available: bool - added:
field DuckArrayModule.module: ModuleType | None - added:
field DuckArrayModule.type: DuckArrayTypes - added:
field DuckArrayModule.version: Version - added:
function array_type(mod: ModType) -> DuckArrayTypes - added:
function is_0d_dask_array(x: duckarray[Any, Any]) -> bool - added:
function is_chunked_array(x: duckarray[Any, Any]) -> bool - added:
function mod_version(mod: ModType) -> Version - added:
function to_duck_array(data: Any, **kwargs: dict[str, Any]) -> duckarray[_ShapeType, _DType] - added:
function to_numpy(data: duckarray[Any, Any], **kwargs: dict[str, Any]) -> np.ndarray[Any, np.dtype[Any]] - added:
variable DuckArrayTypes - added:
variable ModType - added:
variable integer_types
- changed:
function module_available(module: str) -> bool → function module_available(module: str, minversion: str | None=…) -> bool - added:
function drop_missing_dims(supplied_dims: Iterable[_Dim], dims: Iterable[_Dim], missing_dims: ErrorOptionsWithWarn) -> _DimsLike - added:
function either_dict_or_kwargs(pos_kwargs: Mapping[Any, T] | None, kw_kwargs: Mapping[str, T], func_name: str) -> Mapping[Hashable, T] - added:
function infix_dims(dims_supplied: Iterable[_Dim], dims_all: Iterable[_Dim], missing_dims: ErrorOptionsWithWarn=…) -> Iterator[_Dim] - added:
function is_dict_like(value: Any) -> TypeGuard[Mapping[Any, Any]] - added:
function is_duck_array(value: Any) -> TypeGuard[duckarray[Any, Any]] - added:
variable K - added:
variable T - added:
variable V
- changed:
variable external_urls → variable external_urls: dict
- added:
variable abs - added:
variable absolute - added:
variable acos - added:
variable acosh - added:
variable add - added:
variable angle - added:
variable arccos - added:
variable arccosh - added:
variable arcsin - added:
variable arcsinh - added:
variable arctan - added:
variable arctan2 - added:
variable arctanh - added:
variable asin - added:
variable asinh - added:
variable atan - added:
variable atan2 - added:
variable atanh - added:
variable bitwise_and - added:
variable bitwise_count - added:
variable bitwise_invert - added:
variable bitwise_left_shift - added:
variable bitwise_not - added:
variable bitwise_or - added:
variable bitwise_right_shift - added:
variable bitwise_xor - added:
variable cbrt - added:
variable ceil - added:
variable conj - added:
variable conjugate - added:
variable copysign - added:
variable cos - added:
variable cosh - added:
variable deg2rad - added:
variable degrees - added:
variable divide - added:
variable equal - added:
variable exp - added:
variable exp2 - added:
variable expm1 - added:
variable fabs - added:
variable float_power - added:
variable floor - added:
variable floor_divide - added:
variable fmax - added:
variable fmin - added:
variable fmod - added:
variable gcd - added:
variable greater - added:
variable greater_equal - added:
variable heaviside - added:
variable hypot - added:
variable invert - added:
variable iscomplex - added:
variable isfinite - added:
variable isinf - added:
variable isnan - added:
variable isnat - added:
variable isreal - added:
variable lcm - added:
variable ldexp - added:
variable left_shift - added:
variable less - added:
variable less_equal - added:
variable log - added:
variable log10 - added:
variable log1p - added:
variable log2 - added:
variable logaddexp - added:
variable logaddexp2 - added:
variable logical_and - added:
variable logical_not - added:
variable logical_or - added:
variable logical_xor - added:
variable maximum - added:
variable minimum - added:
variable mod - added:
variable multiply - added:
variable negative - added:
variable nextafter - added:
variable not_equal - added:
variable positive - added:
variable pow - added:
variable power - added:
variable rad2deg - added:
variable radians - added:
variable reciprocal - added:
variable remainder - added:
variable right_shift - added:
variable rint - added:
variable sign - added:
variable signbit - added:
variable sin - added:
variable sinh - added:
variable spacing - added:
variable sqrt - added:
variable square - added:
variable subtract - added:
variable tan - added:
variable tanh - added:
variable true_divide - added:
variable trunc
- changed:
function deprecate_dims(func: T) -> T → function deprecate_dims(func: T, old_name=…) -> T
- changed:
constructor Method(name, bool_reduce=…, extra_kwargs=…, numeric_only=…, see_also_modules=…) → constructor Method(name, bool_reduce=…, extra_kwargs=…, numeric_only=…, see_also_modules=…, see_also_methods=…, min_flox_version=…, additional_notes=…) - changed:
field DataStructure.see_also_modules: tuple[str] → field DataStructure.see_also_modules: tuple[str, ...] - changed:
method AggregationGenerator.generate_method(method) → method AggregationGenerator.generate_method(method: Method) - added:
variable DATATREE_GENERATOR - added:
variable DATATREE_OBJECT
- changed:
function binops_overload(other_type: str, overload_type: str, return_type: str=…, type_ignore_eq: str=…) -> list[OpsType] → function binops_overload(other_type: str, overload_types: list[str], return_type: str=…, type_ignore_eq: str=…) -> list[OpsType]