firecube 0.1.4__py3-none-any.whl

firecube/core/formats/__init__.py

@@ -0,0 +1,46 @@
+# Copyright 2025-2026 EUMETSAT
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generic input format helpers (ZIP, HDF5, NetCDF, file discovery).
+
+Public imports remain stable at ``firecube.core.formats``.
+"""
+
+from firecube.core.formats.discovery import KNOWN_EXTENSIONS, discover_input_files
+from firecube.core.formats.hdf5 import materialize_hdf5_path, read_hdf5_array
+from firecube.core.formats.netcdf import (
+    clean_netcdf_encoding,
+    normalize_string_vars,
+    prepare_netcdf_for_zarr,
+    rename_time_dim,
+)
+from firecube.core.formats.zip import (
+    extract_hdf5_from_zip,
+    extract_zip_files_parallel,
+    stream_hdf5_from_zip,
+)
+
+__all__ = [
+    "KNOWN_EXTENSIONS",
+    "clean_netcdf_encoding",
+    "discover_input_files",
+    "extract_hdf5_from_zip",
+    "extract_zip_files_parallel",
+    "materialize_hdf5_path",
+    "normalize_string_vars",
+    "prepare_netcdf_for_zarr",
+    "read_hdf5_array",
+    "rename_time_dim",
+    "stream_hdf5_from_zip",
+]

firecube/core/formats/_iso.py

@@ -0,0 +1,84 @@
+# Copyright 2025-2026 EUMETSAT
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Strict UTC ISO-8601 → numpy.datetime64 helpers. Package-private."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from datetime import datetime, timedelta
+
+import numpy as np
+
+
+def _parse_iso_utc(s: str) -> datetime:
+    """Parse a strict UTC ISO-8601 string to a naive UTC datetime.
+
+    Accepts Z suffix or explicit +00:00 offset. Rejects non-UTC offsets
+    with NotImplementedError. Rejects timezone-naive, malformed, or empty strings
+    with ValueError.
+    """
+    if not isinstance(s, str):
+        raise ValueError(f"expected str, got {type(s).__name__!r}")
+    if not s:
+        raise ValueError("empty ISO string")
+    if _fractional_second_digits(s) > 6:
+        raise ValueError(f"unparseable ISO string: {s!r}")
+
+    normalized = s[:-1] + "+00:00" if s.endswith("Z") else s
+    try:
+        dt = datetime.fromisoformat(normalized)
+    except ValueError as exc:
+        raise ValueError(f"unparseable ISO string: {s!r}") from exc
+
+    if dt.tzinfo is None:
+        raise ValueError(
+            f"timezone-naive ISO string: {s!r}; expected UTC with 'Z' or '+00:00' suffix"
+        )
+    if dt.utcoffset() != timedelta(0):
+        raise NotImplementedError(f"non-UTC ISO string: {s!r} (offset={dt.utcoffset()})")
+    dt = dt.replace(tzinfo=None)
+
+    return dt
+
+
+def _fractional_second_digits(s: str) -> int:
+    if "." not in s:
+        return 0
+
+    fraction = s.rsplit(".", maxsplit=1)[1]
+    for separator in ("Z", "+", "-"):
+        fraction = fraction.split(separator, maxsplit=1)[0]
+    return len(fraction)
+
+
+def _iso_strs_to_datetime64(strs: Iterable[str]) -> np.ndarray:
+    """Convert an iterable of strict UTC ISO-8601 strings to datetime64.
+
+    Precision is auto-detected from the input: datetime64[s] when no string
+    contains a fractional-second component, datetime64[us] otherwise.
+    The whole array uses a single unit (upgraded to [us] if any element has
+    fractional-second syntax).
+
+    Raises ValueError for malformed or non-UTC strings, and for strings with
+    more than 6 fractional digits (nanosecond precision; stdlib limit).
+    """
+    strs_list = list(strs)
+    if not strs_list:
+        return np.array([], dtype="datetime64[s]")
+
+    has_frac = any("." in s for s in strs_list)
+    unit = "us" if has_frac else "s"
+    parsed = [_parse_iso_utc(s) for s in strs_list]
+    return np.asarray(parsed, dtype=f"datetime64[{unit}]")

firecube/core/formats/discovery.py

@@ -0,0 +1,165 @@
+# Copyright 2025-2026 EUMETSAT
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Input file discovery helpers for ingestion plugins.
+
+Format-agnostic discovery utilities that walk a local path or remote URI
+and return candidate input file URIs (ZIP, HDF5, NetCDF, ...).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import fnmatch
+from collections.abc import Iterable, Sequence
+from pathlib import Path
+from typing import Any
+
+from firecube.core.formats.hdf5 import looks_like_hdf5
+from firecube.core.uris import is_remote_target, parse_uri
+
+# All file extensions recognised by the firecube ecosystem.
+# The first three are the defaults for ``discover_input_files``; additional
+# formats (e.g. ``.tgm``) must be requested explicitly via *include_suffixes*.
+KNOWN_EXTENSIONS: frozenset[str] = frozenset({".zip", ".h5", ".nc", ".tgm"})
+
+
+def _path_matches_any_glob(
+    path: str, patterns: Iterable[str], *, candidates: Iterable[str]
+) -> bool:
+    """Return True when any candidate path matches any glob pattern."""
+    normalized_candidates = {path, *candidates}
+    return any(
+        fnmatch.fnmatch(candidate, pattern)
+        for pattern in patterns
+        for candidate in normalized_candidates
+    )
+
+
+def _filter_discovered_paths(
+    paths: Iterable[str],
+    *,
+    source_uri: str,
+    include_suffixes: Sequence[str],
+    preferred_globs: Iterable[str] | None,
+    recursive: bool,
+    sniff_hdf5: bool,
+    exclude: Iterable[str] | None,
+    fs: Any,
+    root: str,
+) -> list[str]:
+    """Filter discovered filesystem paths down to candidate input files."""
+    remote_source = is_remote_target(source_uri)
+    suffixes = {s.lower() for s in include_suffixes}
+    preferred_patterns = tuple(preferred_globs or ())
+    excluded_patterns = tuple(exclude or ())
+    source_is_dir = False
+    with contextlib.suppress(Exception):
+        source_is_dir = bool(fs.isdir(root))
+
+    root_prefix = root.rstrip("/")
+    resolved: list[str] = []
+
+    for path in paths:
+        normalized = str(path)
+        path_for_match = parse_uri(normalized)["path"] if remote_source else normalized
+        basename = Path(path_for_match).name
+        relative = path_for_match
+
+        if root_prefix and path_for_match.startswith(f"{root_prefix}/"):
+            relative = path_for_match[len(root_prefix) + 1 :]
+        elif path_for_match == root_prefix:
+            relative = basename
+
+        if not recursive and "/" in relative:
+            continue
+
+        glob_candidates = {basename, relative, normalized}
+
+        if excluded_patterns and _path_matches_any_glob(
+            normalized, excluded_patterns, candidates=glob_candidates
+        ):
+            continue
+
+        suffix = Path(path_for_match).suffix.lower()
+        include_by_suffix = suffix in suffixes
+        include_by_sniff = False
+        if sniff_hdf5 and (suffix == "" or suffix not in suffixes):
+            include_by_sniff = looks_like_hdf5(Path(normalized))
+
+        include_by_glob = False
+        if preferred_patterns and source_is_dir:
+            include_by_glob = _path_matches_any_glob(
+                normalized, preferred_patterns, candidates=glob_candidates
+            )
+
+        if include_by_suffix or include_by_sniff or include_by_glob:
+            resolved.append(normalized)
+
+    dedup = dict.fromkeys(resolved)
+    return sorted(dedup, key=lambda path: Path(path).name)
+
+
+def discover_input_files(
+    source: str | Path,
+    *,
+    storage_config: Any | None = None,
+    include_suffixes: Sequence[str] = (".zip", ".h5", ".nc"),
+    preferred_globs: Iterable[str] | None = None,
+    recursive: bool = True,
+    sniff_hdf5: bool = True,
+    exclude: Iterable[str] | None = None,
+) -> list[str]:
+    """Discover input files from a local path or remote URI.
+
+    Selection is intentionally conservative and format-agnostic:
+      - Accept files matching `include_suffixes`
+      - Optionally accept extensionless files that look like HDF5
+      - Optionally add files matched by `preferred_globs` (glob patterns)
+
+    Returns URI/path strings (for example ``/tmp/data/file.nc`` or
+    ``s3://bucket/prefix/file.nc``). ``Path`` inputs are accepted for backward
+    compatibility and are converted to strings internally.
+    """
+    from firecube.core.filesystem.ops import _open_fsspec_url
+    from firecube.core.uris import is_remote_target, parse_uri
+
+    source_uri = str(source)
+    is_remote = is_remote_target(source_uri)
+
+    try:
+        fs, root = _open_fsspec_url(source_uri, storage_config=storage_config)
+    except Exception as exc:
+        raise ValueError(f"Cannot open source location {source_uri!r}: {exc}") from exc
+
+    try:
+        all_paths = [str(path) for path in fs.find(root)]
+    except Exception as exc:
+        raise ValueError(f"Cannot list source location {source_uri!r}: {exc}") from exc
+
+    if is_remote:
+        protocol = parse_uri(source_uri)["protocol"]
+        all_paths = [path if "://" in path else f"{protocol}://{path}" for path in all_paths]
+
+    return _filter_discovered_paths(
+        all_paths,
+        source_uri=source_uri,
+        include_suffixes=include_suffixes,
+        preferred_globs=preferred_globs,
+        recursive=recursive,
+        sniff_hdf5=sniff_hdf5 and not is_remote,
+        exclude=exclude,
+        fs=fs,
+        root=root,
+    )

firecube/core/formats/hdf5.py

@@ -0,0 +1,137 @@
+# Copyright 2025-2026 EUMETSAT
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""HDF5 helpers for ingestion plugins.
+
+Reusable helpers for sniffing, reading, and materializing HDF5 inputs
+(either standalone files or members embedded inside ZIP archives).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from firecube.core.formats.zip import extract_hdf5_from_zip
+
+log = logging.getLogger("firecube.core.formats")
+
+
+def looks_like_hdf5(path: Path) -> bool:
+    """Best-effort magic-number check for HDF5 files without extensions."""
+    try:
+        with path.open("rb") as fh:
+            sig = fh.read(8)
+        return sig == b"\x89HDF\r\n\x1a\n"
+    except Exception:
+        return False
+
+
+def read_hdf5_array(
+    hdf5_path: Path,
+    *,
+    variable: str,
+    logger: logging.Logger | None = None,
+) -> Any:
+    """Read a named array from a local HDF5(-like) file, with xarray fallback.
+
+    Args:
+        hdf5_path: Path to the HDF5 file.
+        variable: Name of the variable/dataset to read.
+        logger: Optional logger for debug messages.
+
+    Returns:
+        Numpy array of the data (float32).
+
+    Raises:
+        KeyError: If the variable is not found.
+        RuntimeError: If dependencies are missing or read fails.
+    """
+    logger = logger or log
+    try:
+        import numpy as np
+    except Exception as exc:
+        raise RuntimeError("numpy is required to read HDF5 inputs") from exc
+
+    try:
+        import h5py
+    except Exception as exc:
+        raise RuntimeError("h5py is required to read HDF5 inputs") from exc
+
+    try:
+        with h5py.File(hdf5_path, "r") as handle:
+            if variable not in handle:
+                raise KeyError(f"{variable} dataset not found in HDF5 file")
+            return np.asarray(handle[variable], dtype=np.float32)
+    except Exception as h5_exc:
+        try:
+            import xarray as xr
+
+            ds = xr.open_dataset(hdf5_path, phony_dims="sort")
+            if variable not in ds:
+                raise KeyError(f"{variable} variable not found in dataset")
+            arr = ds[variable].values.astype(np.float32, copy=False)
+            ds.close()
+            return arr
+        except Exception as xr_exc:
+            raise RuntimeError(
+                f"Failed to read {variable} from {hdf5_path.name}: {h5_exc}"
+            ) from xr_exc
+        finally:
+            with contextlib.suppress(Exception):
+                logger.debug("Fell back to xarray open_dataset for %s", hdf5_path.name)
+
+
+def materialize_hdf5_path(
+    file_path: Path,
+    *,
+    extract_root: Path | None = None,
+    logger: logging.Logger | None = None,
+) -> tuple[Path, tempfile.TemporaryDirectory | None]:
+    """Return a local HDF5 path for a source path (ZIP or direct HDF5-like file).
+
+    If the input is a ZIP file, it extracts the content to a temporary directory.
+    If it is already an HDF5-like file, it is returned as-is.
+
+    Args:
+        file_path: Source file path.
+        extract_root: Optional root directory for temporary extraction.
+        logger: Optional logger.
+
+    Returns:
+        Tuple of (path_to_hdf5_file, temporary_directory_object_or_None).
+    """
+    logger = logger or log
+    if file_path.suffix.lower() != ".zip":
+        return file_path, None
+
+    tmp_dir: tempfile.TemporaryDirectory | None
+    if extract_root is None:
+        tmp_dir = tempfile.TemporaryDirectory()
+    else:
+        extract_root.mkdir(parents=True, exist_ok=True)
+        tmp_dir = tempfile.TemporaryDirectory(dir=str(extract_root))
+
+    try:
+        extracted = extract_hdf5_from_zip(file_path, Path(tmp_dir.name), logger=logger)
+        if extracted is None:
+            raise FileNotFoundError(f"No HDF5 member found in archive {file_path.name}")
+        return extracted, tmp_dir
+    except Exception:
+        with contextlib.suppress(Exception):
+            tmp_dir.cleanup()
+        raise

firecube/core/formats/netcdf.py

@@ -0,0 +1,226 @@
+# Copyright 2025-2026 EUMETSAT
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""NetCDF-to-Zarr preparation utilities.
+
+Composable helpers that normalize xarray Datasets loaded from NetCDF
+sources into the shape expected by Firecube's Zarr writer. Plugin-agnostic.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Collection
+from contextlib import suppress
+
+import numpy as np
+import xarray as xr
+
+from firecube.core.formats._iso import _iso_strs_to_datetime64
+
+
+def clean_netcdf_encoding(ds: xr.Dataset) -> xr.Dataset:
+    """Strip HDF5 chunk hints from all variable encodings.
+
+    Removes 'chunks', 'chunksizes', and 'preferred_chunks' from each
+    variable's encoding dict so they do not conflict with the Zarr chunk
+    layout chosen by the core writer. Modifies encoding dicts in place;
+    returns the same dataset object.
+    """
+    for var_name in list(ds.variables):
+        enc = ds[var_name].encoding
+        enc.pop("chunks", None)
+        enc.pop("chunksizes", None)
+        enc.pop("preferred_chunks", None)
+    return ds
+
+
+def rename_time_dim(
+    ds: xr.Dataset,
+    source: str = "time",
+    target: str = "timestamp",
+) -> xr.Dataset:
+    """Rename the time dimension to Firecube's append convention.
+
+    If *source* exists as a dimension or coordinate, rename it to *target*.
+    If *source* is not present, return the dataset unchanged (no error).
+    """
+    if source in ds.dims or source in ds.coords:
+        return ds.rename({source: target})
+    return ds
+
+
+def prepare_netcdf_for_zarr(
+    ds: xr.Dataset,
+    time_dim: str = "time",
+    target_time_dim: str = "timestamp",
+) -> xr.Dataset:
+    """Convenience wrapper: rename time dimension then clean encodings.
+
+    Applies all standard NetCDF→Zarr V3 preparation steps in order:
+    1. Rename time dimension from *time_dim* to *target_time_dim*.
+    2. Strip HDF5 chunk hints from all variable encodings.
+    """
+    ds = rename_time_dim(ds, source=time_dim, target=target_time_dim)
+    ds = clean_netcdf_encoding(ds)
+    return ds
+
+
+# ─── string variable normalization ─────────────────────────
+
+_ACCEPTED_ELEMENT_TYPES: tuple[type, ...] = (str, bytes, np.str_, np.bytes_)
+
+
+def _is_string_var_pure(values: np.ndarray) -> bool:
+    """Pure predicate: True when values holds a string-typed var we can normalize.
+
+    Returns False for anything we cannot confidently classify; never raises.
+    """
+    kind = values.dtype.kind
+    if kind in ("S", "U"):
+        return True
+    if kind != "O" or values.size == 0:
+        return False
+    return all(isinstance(x, _ACCEPTED_ELEMENT_TYPES) for x in values.ravel())
+
+
+def _values_to_str_list(values: np.ndarray) -> list[str]:
+    """Convert a string-shaped ndarray to a flat list of Python str."""
+    kind = values.dtype.kind
+    if kind == "U":
+        return values.ravel().tolist()
+    if kind == "S":
+        try:
+            return np.char.decode(values, "utf-8").ravel().tolist()
+        except UnicodeDecodeError as exc:
+            raise ValueError(f"invalid UTF-8 bytes in string var: {exc}") from exc
+    out: list[str] = []
+    for x in values.ravel():
+        if isinstance(x, str):
+            out.append(x)
+        elif isinstance(x, (bytes, np.bytes_)):
+            try:
+                out.append(x.decode("utf-8"))
+            except UnicodeDecodeError as exc:
+                raise ValueError(f"invalid UTF-8 bytes in string var: {exc}") from exc
+        else:
+            out.append(str(x))
+    return out
+
+
+def normalize_string_vars(
+    ds: xr.Dataset,
+    *,
+    iso_targets: Collection[str] | None = None,
+    logger: logging.Logger | None = None,
+    preserve_cf_time_attrs: bool = False,
+) -> xr.Dataset:
+    """Normalize string-typed variables in a NetCDF-loaded Dataset for Zarr writes.
+
+    Detects string vars by dtype kind (``S``, ``U``, or ``O`` with all-string
+    content) and applies one of:
+
+    - **ISO conversion**: vars named in ``iso_targets`` are converted from ISO-8601
+      UTC strings to ``datetime64[s]`` or ``datetime64[us]`` (auto-detected by
+      fractional-second presence). By default, ``units`` and ``calendar`` attrs (if
+      present on the source variable) are moved from ``.attrs`` to ``.encoding`` on
+      the converted variable — matching xarray's convention for decoded CF time
+      metadata (metadata consumed during conversion is relocated to encoding rather
+      than deleted). Set ``preserve_cf_time_attrs=True`` to keep them verbatim in
+      ``.attrs``; note that firecube's CF advisor may then flag the variable. The
+      returned ISO-converted variable always receives fresh ``.encoding`` — source
+      encoding hints (chunks, dtype, pre-existing time-decode keys) are NOT copied.
+    - **UTF-8 decode**: other string vars are decoded to ``<U*>`` (bytes decoded,
+      object arrays consolidated to fixed-width).
+
+    Variables whose dtype is ``datetime64`` are silently skipped even if named in
+    ``iso_targets`` (already decoded — nothing to do). Variables with non-string
+    object content are also silently skipped, with a DEBUG log when ``logger`` is
+    provided.
+
+    Raises ``ValueError`` only when a name in ``iso_targets`` exists in the dataset
+    AND its data cannot be processed (empty object array, non-string object content,
+    unparseable ISO string, or invalid UTF-8 bytes). A name in ``iso_targets`` that
+    is absent from the dataset is silently skipped.
+
+    This utility normalizes detectable string variables. It does NOT validate
+    whole-dataset Zarr writability; callers who require strict schemas should run a
+    separate validator.
+
+    Args:
+        ds: Input dataset (post-concat is fine; handles vlen-string widening).
+        iso_targets: Variable names to convert to ``datetime64``. ``None`` skips
+            ISO conversion (UTF-8 decode is still applied to other string vars).
+        logger: Optional logger for DEBUG-level skip diagnostics.
+        preserve_cf_time_attrs: If True, keep ``units`` and ``calendar`` attrs on
+            ISO-converted variables verbatim in ``.attrs`` and do NOT write them to
+            ``.encoding``. Default False moves them to ``.encoding`` (xarray convention).
+            Ignored for CF-time attr handling when no variable is ISO-converted; other
+            string normalization still runs.
+
+    Returns:
+        A new dataset. The input is not mutated.
+    """
+    iso_target_set: frozenset[str] = frozenset(iso_targets or ())
+    replacements: dict[str, xr.DataArray] = {}
+
+    for name, var in ds.data_vars.items():
+        var_name = str(name)
+        values = np.asarray(var.values)
+
+        if values.dtype.kind == "M":
+            continue
+
+        is_str = _is_string_var_pure(values)
+        in_targets = var_name in iso_target_set
+
+        if in_targets and not is_str:
+            raise ValueError(
+                f"variable {var_name!r} is in iso_targets but is not a normalizable "
+                f"string var (dtype.kind={values.dtype.kind!r}, size={values.size})"
+            )
+
+        if not is_str:
+            if values.dtype.kind == "O" and logger is not None:
+                logger.debug(
+                    "normalize_string_vars: skipping object-dtype var %r (size=%d)",
+                    var_name,
+                    values.size,
+                )
+            continue
+
+        strs = _values_to_str_list(values)
+        if in_targets:
+            new_values = _iso_strs_to_datetime64(strs).reshape(values.shape)
+            new_attrs = dict(var.attrs)
+            new_encoding: dict[str, object] = {}
+            if not preserve_cf_time_attrs:
+                # Match xarray's pop_to() convention (xarray/coding/times.py:1407):
+                # attrs consumed during type conversion move to .encoding, preserving
+                # metadata without polluting .attrs on the decoded array.
+                for key in ("units", "calendar"):
+                    if key in new_attrs:
+                        new_encoding[key] = new_attrs.pop(key)
+            new_da = xr.DataArray(new_values, dims=var.dims, attrs=new_attrs, name=var_name)
+            new_da.encoding = new_encoding
+            replacements[var_name] = new_da
+        else:
+            new_values = np.asarray(strs, dtype=object).reshape(values.shape)
+            with suppress(UnicodeDecodeError, ValueError):
+                new_values = new_values.astype(str)
+            replacements[var_name] = xr.DataArray(
+                new_values, dims=var.dims, attrs=dict(var.attrs), name=var_name
+            )
+
+    return ds.assign(replacements)