quantized-lab 0.8.0__py3-none-any.whl

quantized/io/lakeshore.py

@@ -0,0 +1,163 @@
+"""Lake Shore VSM ``.csv``/``.dat`` parser. Port of MATLAB parser.importLakeShore.
+
+Auto-detects the column-header row (first comma line with >50% non-numeric
+fields), then defaults to Temperature (x) vs Moment (y).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from quantized.datastruct import DataStruct
+from quantized.io.base import NO_COLUMN, parse_col_header, resolve_column
+
+__all__ = ["import_lake_shore", "is_lakeshore_file"]
+
+_LS_SHORTHAND: dict[str, str] = {
+    "temp": "Temperature",
+    "temperature": "Temperature",
+    "field": "Magnetic Field",
+    "appliedfield": "Magnetic Field",
+    "moment": "Moment",
+}
+
+
+def _is_nan_token(token: str) -> bool:
+    try:
+        float(token)
+        return False
+    except ValueError:
+        return True
+
+
+def _to_float(token: str) -> float:
+    token = token.strip()
+    if not token:
+        return float("nan")
+    try:
+        return float(token)
+    except ValueError:
+        return float("nan")
+
+
+def _detect_header_row(lines: Sequence[str]) -> int:
+    """First line (of the first 100) with a comma and >50% non-numeric fields."""
+    for i, raw in enumerate(lines[:100]):
+        line = raw.strip()
+        if not line or "," not in line:
+            continue
+        parts = [p.strip() for p in line.split(",")]
+        if len(parts) < 2:
+            continue
+        text_count = sum(1 for p in parts if _is_nan_token(p))
+        if text_count / len(parts) > 0.5:
+            return i
+    return -1
+
+
+def import_lake_shore(
+    filepath: str | Path,
+    *,
+    x_axis: str | int = "temp",
+    y_axis: str | int | Sequence[str | int] = "moment",
+) -> DataStruct:
+    """Import a Lake Shore VSM file (Temperature vs Moment by default)."""
+    path = Path(filepath)
+    lines = path.read_text(encoding="latin-1").splitlines()
+    header_idx = _detect_header_row(lines)
+    if header_idx < 0:
+        raise ValueError(f"could not detect column-header row in {path.name}")
+
+    raw_cols = [c.strip() for c in lines[header_idx].split(",")]
+    n_cols = len(raw_cols)
+    col_names: list[str] = []
+    col_units: list[str] = []
+    for cell in raw_cols:
+        name, unit = parse_col_header(cell)
+        col_names.append(name)
+        col_units.append(unit)
+
+    rows: list[list[float]] = []
+    for raw in lines[header_idx + 1 :]:
+        if not raw.strip():
+            continue  # drop blank rows only (MATLAB parity)
+        parts = raw.split(",")
+        row = [float("nan")] * n_cols
+        for c in range(min(len(parts), n_cols)):
+            row[c] = _to_float(parts[c])
+        rows.append(row)
+    if not rows:
+        raise ValueError(f"no data rows in {path.name}")
+    matrix = np.asarray(rows, dtype=float)
+
+    x_idx = resolve_column(x_axis, col_names, _LS_SHORTHAND, "x-axis")
+    if x_idx == NO_COLUMN:
+        raise ValueError("x-axis column could not be resolved")
+    if isinstance(y_axis, str) and y_axis.lower() == "all":
+        y_idx = [c for c in range(n_cols) if c != x_idx]
+    else:
+        specs: list[str | int] = [y_axis] if isinstance(y_axis, (str, int)) else list(y_axis)
+        # resolve_column raises KeyError for an unresolvable name and returns
+        # NO_COLUMN (-1) for empty specs - the latter would silently index the
+        # LAST column as the signal (latent while the parser was unregistered;
+        # reachable via import_auto since MAIN #7). Normalize both to a clean
+        # ValueError like every other unresolved-column path.
+        y_idx = []
+        unresolved: list[str] = []
+        for spec in specs:
+            try:
+                idx = resolve_column(spec, col_names, _LS_SHORTHAND, "y-axis")
+            except KeyError:
+                unresolved.append(str(spec))
+                continue
+            if idx == NO_COLUMN:
+                unresolved.append(str(spec))
+            else:
+                y_idx.append(idx)
+        if unresolved:
+            raise ValueError(
+                "y-axis column(s) could not be resolved: " + ", ".join(unresolved)
+            )
+    if not y_idx:
+        raise ValueError("no y-axis columns resolved")
+
+    metadata: dict[str, Any] = {
+        "source": str(path),
+        "parser_name": "import_lake_shore",
+        "x_column_name": col_names[x_idx],
+        "x_column_unit": col_units[x_idx],
+        "all_column_names": col_names,
+        "all_column_units": col_units,
+    }
+    return DataStruct.create(
+        matrix[:, x_idx],
+        matrix[:, y_idx],
+        labels=[col_names[i] for i in y_idx],
+        units=[col_units[i] for i in y_idx],
+        metadata=metadata,
+    )
+
+
+def is_lakeshore_file(path: Path) -> bool:
+    """Content sniffer for ambiguous ``.csv``/``.dat``: True for a Lake Shore
+    VSM export — the instrument writes a "Lake Shore" preamble line above the
+    column-header row (see the module docstring). Tight on purpose: a generic
+    CSV only matches if it self-identifies as Lake Shore in its first 2 KB.
+    A sniffer must never raise; unreadable -> not Lake Shore."""
+    try:
+        text = Path(path).read_text(encoding="latin-1", errors="replace")[:2048]
+    except Exception:  # noqa: BLE001
+        return False
+    lower = text.lower()
+    # Vendor marker must sit in the PREAMBLE (the instrument titles the file),
+    # not merely appear anywhere - a generic CSV mentioning "Lake Shore" in a
+    # comment or data column must NOT reroute away from import_csv. And the
+    # header region must actually carry a resolvable instrument column.
+    head_lines = [ln.strip().lower() for ln in lower.splitlines()[:3]]
+    if not any("lake shore" in ln for ln in head_lines):
+        return False
+    return any(col in lower for col in ("temperature", "moment", "magnetic field"))

quantized/io/ncnr.py

@@ -0,0 +1,278 @@
+"""NCNR reductus reflectometry parser (.refl). Port of parser.importNCNRRefl.
+
+Format: ``#``-prefixed JSON-ish header (name / polarization / wavelength /
+columns / units) then whitespace-delimited numeric rows. time = Qz (column 0),
+values = the remaining columns (Intensity, uncertainty, resolution). Rows with
+any non-numeric token are dropped (matches MATLAB's any-NaN filter).
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from quantized.datastruct import DataStruct
+
+__all__ = ["import_ncnr_dat", "import_ncnr_pnr", "import_ncnr_refl", "is_ncnr_refl"]
+
+_HEADER_RE = re.compile(r'#\s*"([^"]+)":\s*(.+)$')
+
+
+def _loads(text: str) -> Any:
+    try:
+        return json.loads(text)
+    except (json.JSONDecodeError, ValueError):
+        return None
+
+
+def is_ncnr_refl(path: str | Path) -> bool:
+    """Sniff a ``.refl`` as NCNR reductus output: its ``#``-comment header carries
+    a JSON ``"columns": [...]`` line. A refl1d-exported ``.refl`` instead uses a
+    plain ``Q (1/A) R dR`` column line, so it won't match — letting the registry
+    route it to the refl1d parser. Scans the header line-by-line (the reductus
+    ``"template_data"`` line alone can exceed several KB, so a fixed byte slice
+    would miss the later ``"columns"`` key) and stops at the first data row."""
+    with Path(path).open(encoding="latin-1", errors="replace") as fh:
+        for raw in fh:
+            line = raw.rstrip("\n")
+            if not line.startswith("#"):
+                break  # header ended without a "columns" key
+            match = _HEADER_RE.match(line)
+            if match is not None and match.group(1) == "columns":
+                return True
+    return False
+
+
+def import_ncnr_refl(filepath: str | Path) -> DataStruct:
+    """Import an NCNR reductus ``.refl`` file (PBR or CANDOR)."""
+    path = Path(filepath)
+    lines = path.read_text(encoding="latin-1").splitlines()
+
+    name = ""
+    polarization = ""
+    wavelength: list[float] = []
+    columns: list[str] = []
+    units: list[str] = []
+    data_start = len(lines)
+
+    for i, line in enumerate(lines):
+        if not line.startswith("#"):
+            data_start = i
+            break
+        match = _HEADER_RE.match(line)
+        if match is None:
+            continue
+        key, valstr = match.group(1), match.group(2).strip()
+        if key == "name":
+            parsed = _loads(valstr)
+            name = parsed if isinstance(parsed, str) else valstr.strip('"')
+        elif key == "polarization":
+            parsed = _loads(valstr)
+            polarization = parsed if isinstance(parsed, str) else valstr.strip('"')
+        elif key == "wavelength":
+            parsed = _loads(valstr)
+            if isinstance(parsed, list):
+                wavelength = [float(x) for x in parsed]
+            elif isinstance(parsed, (int, float)):
+                wavelength = [float(parsed)]
+        elif key == "columns":
+            parsed = _loads(valstr)
+            if isinstance(parsed, list):
+                columns = [str(x) for x in parsed]
+        elif key == "units":
+            parsed = _loads(valstr)
+            if isinstance(parsed, list):
+                units = [str(x) for x in parsed]
+
+    if not columns:
+        raise ValueError(f"no 'columns' header found in {path.name}")
+
+    rows: list[list[float]] = []
+    for line in lines[data_start:]:
+        text = line.strip()
+        if not text:
+            continue
+        try:
+            rows.append([float(t) for t in text.split()])
+        except ValueError:
+            continue  # any non-numeric token -> drop the row (MATLAB parity)
+    if not rows:
+        raise ValueError(f"no numeric data rows in {path.name}")
+    matrix = np.asarray(rows, dtype=float)
+
+    n_cols = len(columns)
+    qz = matrix[:, 0]
+    values = matrix[:, 1:n_cols]
+    labels = columns[1:n_cols]
+    out_units = [units[j] if j < len(units) else "" for j in range(1, n_cols)]
+
+    instrument_type = "PBR (monochromatic)" if len(wavelength) == 1 else "CANDOR (polychromatic)"
+    metadata: dict[str, Any] = {
+        "source": str(path),
+        "parser_name": "import_ncnr_refl",
+        "x_column_name": "Qz",
+        "x_column_unit": units[0] if units else "1/Ang",
+        "name": name,
+        "polarization": polarization,
+        "instrument_type": instrument_type,
+        "wavelengths": wavelength,
+    }
+    return DataStruct.create(qz, values, labels=labels, units=out_units, metadata=metadata)
+
+
+# ── Polarized .pnr (tab-delimited, 2 header rows) ────────────────────────────
+_POL_REPLACEMENTS = (
+    ("++", "pp"), ("+-", "pm"), ("-+", "mp"), ("--", "mm"), ("+/-", "pm"), ("-/+", "mp"),
+)
+
+
+def _clean_polarization(label: str) -> str:
+    for old, new in _POL_REPLACEMENTS:
+        label = label.replace(old, new)
+    return label
+
+
+def import_ncnr_pnr(filepath: str | Path) -> DataStruct:
+    """Import an NCNR polarized neutron reflectometry ``.pnr`` (tab-delimited)."""
+    path = Path(filepath)
+    lines = path.read_text(encoding="latin-1").splitlines()
+    if len(lines) < 3:
+        raise ValueError(f"{path.name}: too few lines for a .pnr file")
+    col_names = lines[0].strip().split("\t")
+    units = lines[1].strip().split("\t")
+    n_cols = len(col_names)
+
+    rows: list[list[float]] = []
+    for raw in lines[2:]:
+        stripped = raw.strip()
+        if not stripped:
+            continue
+        tokens = stripped.split("\t")
+        if len(tokens) < n_cols:
+            continue
+        try:
+            rows.append([float(t) for t in tokens[:n_cols]])
+        except ValueError:
+            continue
+    if not rows:
+        raise ValueError(f"no numeric data in {path.name}")
+    matrix = np.asarray(rows, dtype=float)
+
+    labels = [_clean_polarization(c) for c in col_names[1:]]
+    out_units = [units[j] if j < len(units) else "" for j in range(1, n_cols)]
+
+    lowered = " ".join(col_names).lower()
+    is_nsf = "r++" in lowered or "r--" in lowered
+    is_sf = "r+-" in lowered or "r-+" in lowered or "r+/-" in lowered
+    if is_nsf and is_sf:
+        variant = "combined"
+    elif is_nsf:
+        variant = "NSF"
+    elif is_sf:
+        variant = "SF"
+    else:
+        variant = "unknown"
+
+    metadata: dict[str, Any] = {
+        "source": str(path),
+        "parser_name": "import_ncnr_pnr",
+        "x_column_name": "Q",
+        "x_column_unit": units[0] if units else "1/Ang",
+        "variant": variant,
+    }
+    return DataStruct.create(
+        matrix[:, 0], matrix[:, 1:], labels=labels, units=out_units, metadata=metadata
+    )
+
+
+# ── refl1d-fit cross sections (.datA/.datB/.datC/.datD) ──────────────────────
+_NCNR_POL_BY_EXT = {".datA": "++", ".datB": "+-", ".datC": "-+", ".datD": "--"}
+_NCNR_DAT_LABELS = ["dQ", "R", "dR", "theory", "fresnel"]
+_NCNR_DAT_UNITS = ["1/A", "", "", "", ""]
+
+
+def _safe_float(text: str) -> float:
+    try:
+        return float(text.strip())
+    except ValueError:
+        return float("nan")
+
+
+def import_ncnr_dat(filepath: str | Path) -> DataStruct:
+    """Import an NCNR refl1d-fit cross section (.datA/.datB/.datC/.datD)."""
+    path = Path(filepath)
+    pol = next(
+        (v for k, v in _NCNR_POL_BY_EXT.items() if k.lower() == path.suffix.lower()), None
+    )
+    if pol is None:
+        raise ValueError(f"{path.name}: expected extension .datA/.datB/.datC/.datD")
+    lines = path.read_text(encoding="latin-1").splitlines()
+
+    intensity = float("nan")
+    background = float("nan")
+    data_start = 0
+    # Scan the whole comment header (not just the first 5 lines) so intensity /
+    # background metadata is captured wherever it sits; the loop still breaks at
+    # the column header or first data row.
+    for i, line in enumerate(lines):
+        if line.startswith("# intensity:"):
+            intensity = _safe_float(line.split(":", 1)[1])
+        elif line.startswith("# background:"):
+            background = _safe_float(line.split(":", 1)[1])
+        elif line.startswith("#") and "Q (1/A)" in line:
+            data_start = i + 1
+            break
+        elif not line.startswith("#"):
+            data_start = i
+            break
+
+    rows: list[list[float]] = []
+    for line in lines[data_start:]:
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        try:
+            rows.append([float(t) for t in stripped.split()])
+        except ValueError:
+            continue
+    if not rows:
+        raise ValueError(f"no numeric data in {path.name}")
+    width = len(rows[0])
+    matrix = np.asarray([r for r in rows if len(r) == width], dtype=float)
+
+    n_val = matrix.shape[1] - 1
+    labels: list[str] = []
+    units: list[str] = []
+    for j in range(n_val):
+        labels.append(_NCNR_DAT_LABELS[j] if j < len(_NCNR_DAT_LABELS) else f"col{j + 1}")
+        units.append(_NCNR_DAT_UNITS[j] if j < len(_NCNR_DAT_UNITS) else "")
+
+    metadata: dict[str, Any] = {
+        "source": str(path),
+        "parser_name": "import_ncnr_dat",
+        "x_column_name": "Q",
+        "x_column_unit": "1/Ang",
+        "polarization": pol,
+    }
+    if not np.isnan(intensity):
+        metadata["intensity"] = intensity
+    if not np.isnan(background):
+        metadata["background"] = background
+    # Plot hints (honoured by the frontend defaults): show the measured
+    # reflectivity R and the fit line 'theory' by default, with dR as R's error
+    # bars; the resolution 'dQ' and normalisation 'fresnel' columns stay off the
+    # plot by default (still toggleable in the Channels card). Keyed by value-
+    # column index (0-based, x/Q excluded).
+    label_idx = {lab: j for j, lab in enumerate(labels)}
+    default_channels = [label_idx[name] for name in ("R", "theory") if name in label_idx]
+    if default_channels:
+        metadata["default_value_channels"] = default_channels
+    if "R" in label_idx and "dR" in label_idx:
+        metadata["error_channels"] = {label_idx["R"]: label_idx["dR"]}
+    return DataStruct.create(
+        matrix[:, 0], matrix[:, 1:], labels=labels, units=units, metadata=metadata
+    )

quantized/io/netcdf.py

@@ -0,0 +1,195 @@
+"""NetCDF import (``.nc`` / ``.cdf``) — chromatography (ANDI/AIA) + generic.
+
+NetCDF is a self-describing container, so this parser has two layers:
+
+* a **reader** that normalizes both on-disk formats to a common view —
+  NetCDF-3 "classic"/64-bit (magic ``CDF\\x01``/``\\x02``/``\\x05``) via
+  ``scipy.io.netcdf_file``, and NetCDF-4 (HDF5-backed, magic ``\\x89HDF``) via
+  ``h5py``. Both are existing quantized deps (no new dependency);
+* an **interpreter** that recognizes the ANDI/AIA Chromatography convention
+  (``total_intensity`` vs ``scan_acquisition_time`` = a TIC; or
+  ``ordinate_values`` + sampling interval = a single-channel trace) and
+  otherwise falls back to a generic "pick the monotonic coordinate as x, the
+  rest as channels" heuristic.
+
+Pure layer: ndarray/DataStruct in -> out. No fastapi/pydantic imports.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from quantized.datastruct import DataStruct
+
+__all__ = ["import_netcdf", "is_netcdf"]
+
+_CDF_MAGICS = (b"CDF\x01", b"CDF\x02", b"CDF\x05")
+_HDF5_MAGIC = b"\x89HDF"
+
+
+@dataclass
+class _Var:
+    data: np.ndarray
+    units: str = ""
+
+
+@dataclass
+class _NcData:
+    variables: dict[str, _Var]
+    attrs: dict[str, Any] = field(default_factory=dict)
+
+
+def is_netcdf(path: Path) -> bool:
+    """Sniff a file as NetCDF-3 (``CDF``) or NetCDF-4/HDF5 (``\\x89HDF``)."""
+    with Path(path).open("rb") as fh:
+        head = fh.read(4)
+    return head in _CDF_MAGICS or head == _HDF5_MAGIC
+
+
+def _as_str(value: Any) -> str:
+    if isinstance(value, bytes):
+        return value.decode("latin-1", "replace").strip()
+    return str(value).strip()
+
+
+def _read_netcdf3(path: Path) -> _NcData:
+    from scipy.io import netcdf_file  # noqa: PLC0415
+
+    f = netcdf_file(str(path), "r", mmap=False)
+    try:
+        variables = {
+            name: _Var(np.asarray(var[:], dtype=float) if var.data.dtype.kind in "fiu"
+                       else np.asarray(var[:]),
+                       _as_str(getattr(var, "units", b"")))
+            for name, var in f.variables.items()
+        }
+        attrs = {k: _as_str(v) if isinstance(v, bytes) else v
+                 for k, v in f._attributes.items()}  # noqa: SLF001 (scipy's public-in-practice map)
+    finally:
+        f.close()
+    return _NcData(variables, attrs)
+
+
+def _read_netcdf4(path: Path) -> _NcData:
+    import h5py  # noqa: PLC0415
+
+    variables: dict[str, _Var] = {}
+    with h5py.File(path, "r") as h:
+        def _collect(name: str, obj: Any) -> None:
+            if isinstance(obj, h5py.Dataset) and obj.ndim <= 1:
+                key = name.rsplit("/", 1)[-1]
+                variables[key] = _Var(np.asarray(obj[()]), _as_str(obj.attrs.get("units", "")))
+
+        h.visititems(_collect)
+        attrs = {k: _as_str(v) if isinstance(v, bytes) else v for k, v in h.attrs.items()}
+    return _NcData(variables, attrs)
+
+
+def _numeric_1d(nc: _NcData) -> dict[str, _Var]:
+    return {
+        n: v for n, v in nc.variables.items()
+        if v.data.ndim == 1 and v.data.size > 1 and v.data.dtype.kind in "fiu"
+    }
+
+
+def _is_monotonic(a: np.ndarray) -> bool:
+    d = np.diff(a)
+    return bool(np.all(d > 0) or np.all(d < 0))
+
+
+def _andi_axes(
+    nc: _NcData,
+) -> tuple[np.ndarray, np.ndarray, str, str, str, str] | None:
+    """Return (x, y, x_name, x_unit, y_label, y_unit) for ANDI/AIA, else None."""
+    v = nc.variables
+    if "total_intensity" in v and "scan_acquisition_time" in v:
+        t, tic = v["scan_acquisition_time"], v["total_intensity"]
+        return (np.asarray(t.data, float), np.asarray(tic.data, float),
+                "Retention Time", t.units or "seconds", "Total Intensity",
+                tic.units or "counts")
+    if "ordinate_values" in v:
+        y = np.asarray(v["ordinate_values"].data, float)
+        interval = _attr_float(nc, "actual_sampling_interval")
+        delay = _attr_float(nc, "actual_delay_time", 0.0) or 0.0
+        x = delay + np.arange(y.size) * interval if interval is not None \
+            else np.arange(y.size, dtype=float)
+        return x, y, "Retention Time", "seconds", "Signal", v["ordinate_values"].units or ""
+    return None
+
+
+def _attr_float(nc: _NcData, key: str, default: float | None = None) -> float | None:
+    if key in nc.attrs:
+        try:
+            return float(nc.attrs[key])
+        except (TypeError, ValueError):
+            return default
+    if key in nc.variables and nc.variables[key].data.size == 1:
+        return float(np.asarray(nc.variables[key].data).ravel()[0])
+    return default
+
+
+def import_netcdf(filepath: str | Path) -> DataStruct:
+    """Import a NetCDF ``.nc``/``.cdf`` into a DataStruct.
+
+    ANDI/AIA chromatography files yield the total-ion-current (or single
+    detector) trace vs retention time; generic files use the monotonic
+    coordinate variable as x and the remaining 1-D numeric variables as
+    channels.
+    """
+    path = Path(filepath)
+    with path.open("rb") as fh:
+        magic = fh.read(4)
+    if magic in _CDF_MAGICS:
+        nc = _read_netcdf3(path)
+    elif magic == _HDF5_MAGIC:
+        nc = _read_netcdf4(path)
+    else:
+        raise ValueError(f"not a NetCDF/HDF5 file (magic {magic!r}): {path.name}")
+
+    andi = _andi_axes(nc)
+    if andi is not None:
+        x, y, x_name, x_unit, y_label, y_unit = andi
+        return _build(path, x, y[:, None], [y_label], [y_unit], x_name, x_unit, nc, "ANDI")
+
+    numeric = _numeric_1d(nc)
+    if not numeric:
+        raise ValueError(f"no 1-D numeric variables to import: {path.name}")
+
+    names = list(numeric)
+    x_key = next((n for n in names if _is_monotonic(numeric[n].data)), names[0])
+    x = np.asarray(numeric[x_key].data, float)
+    channels = [n for n in names if n != x_key and numeric[n].data.size == x.size]
+    if not channels:  # a single variable: index it
+        return _build(path, np.arange(x.size, dtype=float), x[:, None],
+                      [_titlecase(x_key)], [numeric[x_key].units], "Index", "", nc, "generic")
+
+    values = np.column_stack([numeric[n].data for n in channels])
+    return _build(path, x, values, [_titlecase(n) for n in channels],
+                  [numeric[n].units for n in channels], _titlecase(x_key),
+                  numeric[x_key].units, nc, "generic")
+
+
+def _titlecase(name: str) -> str:
+    return name.replace("_", " ").title()
+
+
+def _build(
+    path: Path, x: np.ndarray, values: np.ndarray, labels: list[str], units: list[str],
+    x_name: str, x_unit: str, nc: _NcData, kind: str,
+) -> DataStruct:
+    metadata: dict[str, Any] = {
+        "source": str(path),
+        "parser_name": "import_netcdf",
+        "netcdf_kind": kind,
+        "x_column_name": x_name,
+        "x_column_unit": x_unit,
+        "num_points": int(x.size),
+    }
+    for k in ("aia_template_revision", "netcdf_revision", "experiment_type", "title"):
+        if k in nc.attrs:
+            metadata[k] = nc.attrs[k]
+    return DataStruct.create(x, values, labels=labels, units=units, metadata=metadata)