nd-arrow-array 0.5.0__cp39-abi3-win_amd64.whl

nd_arrow_array/__init__.py

@@ -0,0 +1,14 @@
+"""N-dimensional Arrow arrays."""
+
+from importlib.metadata import version as _version
+
+from ._core import NdArray, NdColumn, NdFormatError, NdRecordBatch, encode_batches
+
+__all__ = [
+    "NdArray",
+    "NdColumn",
+    "NdFormatError",
+    "NdRecordBatch",
+    "encode_batches",
+]
+__version__ = _version("nd-arrow-array")

nd_arrow_array/_core.pyi

@@ -0,0 +1,148 @@
+from typing import Any, Iterator, Mapping, Optional, Protocol, Sequence, Tuple, Union, final
+
+import numpy as np
+import numpy.typing as npt
+
+__all__ = [
+    "NdArray",
+    "NdColumn",
+    "NdRecordBatch",
+    "_ArrowExport",
+    "encode_batches",
+    "NdFormatError",
+    "_roundtrip_numpy",
+    "_roundtrip_attrs",
+]
+
+class _ArrowArrayExportable(Protocol):
+    def __arrow_c_array__(self, requested_schema: Any = None) -> Tuple[Any, Any]: ...
+
+class _ArrowScalar(Protocol):
+    # A pyarrow.Scalar, without a dependency on pyarrow.
+    def as_py(self) -> Any: ...
+
+class _ArrowStreamExportable(Protocol):
+    def __arrow_c_stream__(self, requested_schema: Any = None) -> Any: ...
+
+# Dimensions: {"time": 2, "lat": 3} or [("time", 2), ("lat", 3)].
+_Dims = Union[Mapping[str, int], Sequence[Tuple[str, int]]]
+_AttrValue = Union[
+    str,
+    bool,
+    int,
+    float,
+    np.generic,
+    npt.NDArray[Any],
+    Sequence[str],
+    Sequence[int],
+    Sequence[float],
+    _ArrowScalar,
+]
+_Attrs = Optional[Mapping[str, _AttrValue]]
+
+class NdFormatError(ValueError):
+    """Data does not follow the nd_arrow.array format."""
+
+@final
+class NdArray:
+    """One N-dimensional array with named dimensions and attributes."""
+
+    def __new__(
+        cls, values: _ArrowArrayExportable, dims: _Dims, attrs: _Attrs = None
+    ) -> NdArray: ...
+    @staticmethod
+    def from_numpy(
+        arr: npt.ArrayLike, dims: Sequence[str], attrs: _Attrs = None
+    ) -> NdArray: ...
+    @property
+    def dims(self) -> Tuple[str, ...]: ...
+    @property
+    def shape(self) -> Tuple[int, ...]: ...
+    @property
+    def sizes(self) -> dict[str, int]: ...
+    @property
+    def ndim(self) -> int: ...
+    @property
+    def dtype(self) -> str: ...
+    @property
+    def attrs(self) -> dict[str, Any]: ...
+    @attrs.setter
+    def attrs(self, value: _Attrs) -> None: ...
+    @property
+    def values(self) -> Any:
+        """The flat values as a pyarrow.Array. Needs pyarrow."""
+    def set_attr(self, name: str, value: _AttrValue) -> None: ...
+    def del_attr(self, name: str) -> None: ...
+    def with_attrs(self, attrs: _Attrs) -> NdArray: ...
+    def reshape(self, dims: _Dims) -> NdArray: ...
+    def to_numpy(self) -> npt.NDArray[Any]:
+        """A numpy.ndarray, or a numpy.ma.MaskedArray when nulls exist."""
+    def to_xarray(self, name: Optional[str] = None) -> Any:
+        """An xarray.DataArray. Nulls become NaN or NaT. Needs xarray."""
+    @staticmethod
+    def from_xarray(data_array: Any) -> NdArray:
+        """An array from an xarray.DataArray, without coordinates. Needs xarray."""
+    def __arrow_c_array__(self, requested_schema: Any = None) -> Tuple[Any, Any]: ...
+    def __eq__(self, other: object, /) -> bool: ...
+    def __ne__(self, other: object, /) -> bool: ...
+
+@final
+class NdColumn:
+    """An Arrow column of the nd_arrow.array extension type."""
+
+    @staticmethod
+    def from_arrays(items: Sequence[Optional[NdArray]]) -> NdColumn: ...
+    @staticmethod
+    def from_arrow(obj: _ArrowArrayExportable) -> NdColumn: ...
+    def to_arrow(self) -> Any:
+        """The column as a pyarrow.Array. Needs pyarrow."""
+    @property
+    def null_count(self) -> int: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, index: int, /) -> Optional[NdArray]: ...
+    def __iter__(self) -> Iterator[Optional[NdArray]]: ...
+    def __arrow_c_array__(self, requested_schema: Any = None) -> Tuple[Any, Any]: ...
+    def __arrow_c_schema__(self) -> Any: ...
+
+@final
+class NdRecordBatch:
+    """Named nd arrays on one shared grid, like an xarray Dataset."""
+
+    def __new__(
+        cls,
+        columns: Mapping[str, NdArray],
+        attrs: _Attrs = None,
+        target: Optional[_Dims] = None,
+    ) -> NdRecordBatch: ...
+    @staticmethod
+    def from_arrow(
+        obj: Union[_ArrowArrayExportable, _ArrowStreamExportable],
+    ) -> list[NdRecordBatch]: ...
+    @property
+    def target(self) -> dict[str, int]: ...
+    @property
+    def attrs(self) -> dict[str, Any]: ...
+    @attrs.setter
+    def attrs(self, value: _Attrs) -> None: ...
+    def keys(self) -> list[str]: ...
+    def __getitem__(self, name: str, /) -> NdArray: ...
+    def __len__(self) -> int: ...
+    def to_arrow(self) -> Any:
+        """The batch as a one-row pyarrow.RecordBatch. Needs pyarrow."""
+    def to_xarray(self) -> Any:
+        """An xarray.Dataset. Nulls become NaN or NaT. Needs xarray."""
+    @staticmethod
+    def from_xarray(dataset: Any) -> NdRecordBatch:
+        """A batch from an xarray.Dataset or DataArray, with coordinates. Needs xarray."""
+    def __arrow_c_stream__(self, requested_schema: Any = None) -> Any: ...
+    def __arrow_c_schema__(self) -> Any: ...
+
+def encode_batches(batches: Sequence[NdRecordBatch]) -> Any:
+    """Several batches as one pyarrow.RecordBatch, one row each. Needs pyarrow."""
+
+@final
+class _ArrowExport:
+    def __arrow_c_array__(self, requested_schema: Any = None) -> Tuple[Any, Any]: ...
+
+def _roundtrip_numpy(arr: npt.ArrayLike) -> npt.NDArray[Any]: ...
+def _roundtrip_attrs(dict: Mapping[str, _AttrValue]) -> dict[str, Any]: ...

nd_arrow_array/_xarray.py

@@ -0,0 +1,220 @@
+"""Conversion between nd arrays and xarray objects.
+
+The methods ``to_xarray`` and ``from_xarray`` of ``NdArray`` and
+``NdRecordBatch`` call the functions in this module.
+"""
+
+from __future__ import annotations
+
+from types import ModuleType
+from typing import Any, Hashable, Iterable, Mapping
+
+import numpy as np
+
+from ._core import NdArray, NdRecordBatch
+
+# CF attribute that names the non-index coordinates of a variable.
+COORDINATES = "coordinates"
+
+
+def _xr(feature: str) -> ModuleType:
+    try:
+        import xarray
+    except ImportError as error:
+        raise ImportError(
+            f"xarray is required for {feature}: pip install nd-arrow-array[xarray]"
+        ) from error
+    return xarray
+
+
+def _name(key: Hashable, kind: str) -> str:
+    if not isinstance(key, str):
+        raise TypeError(f"{kind} names must be str, got {key!r}")
+    return key
+
+
+def _decode(values: Any) -> np.ndarray[Any, Any]:
+    """Nulls become NaN or NaT, as in xarray."""
+    if not isinstance(values, np.ma.MaskedArray):
+        return np.asarray(values)
+    if not values.mask.any():
+        return values.data
+    kind = values.dtype.kind
+    if kind in "fc":
+        return values.filled(np.nan)
+    if kind in "biu":
+        # Like xarray CF decoding: integers with missing values become float64.
+        return np.where(values.mask, np.nan, values.data.astype(np.float64))
+    if kind in "mM":
+        return values.filled(values.dtype.type("NaT", np.datetime_data(values.dtype)[0]))
+    out = values.data.astype(object)
+    out[values.mask] = np.nan
+    return out
+
+
+def _missing(item: Any) -> bool:
+    return item is None or (isinstance(item, float) and item != item)
+
+
+# Calendars where a cftime date is a real instant. Others are model calendars.
+REAL_CALENDARS = {"standard", "gregorian", "proleptic_gregorian", "julian"}
+MODEL_CALENDARS = {"noleap", "365_day", "all_leap", "366_day", "360_day"}
+US_PER_SECOND = 1_000_000
+
+
+def _cftime_type() -> type | None:
+    try:
+        import cftime  # type: ignore[import-untyped, unused-ignore]
+    except ImportError:
+        return None
+    return cftime.datetime  # type: ignore[no-any-return, unused-ignore]
+
+
+def _elapsed_us(date: Any, calendar: str) -> int:
+    """Microseconds since the Unix epoch of the instant `date`."""
+    import cftime  # type: ignore[import-untyped, unused-ignore]
+
+    # The Unix epoch, 1970-01-01 Gregorian, is 1969-12-19 in the Julian calendar.
+    ymd = (1969, 12, 19) if calendar == "julian" else (1970, 1, 1)
+    epoch = cftime.datetime(*ymd, calendar=calendar, has_year_zero=date.has_year_zero)
+    delta = date - epoch
+    return int((delta.days * 86_400 + delta.seconds) * US_PER_SECOND + delta.microseconds)
+
+
+def _fields_us(date: Any, calendar: str) -> int:
+    """Microseconds since 1970-01-01 of the same date and time in the standard calendar."""
+    month = np.datetime64(date.year - 1970, "Y").astype("M8[M]") + np.timedelta64(date.month - 1, "M")
+    first = month.astype("M8[D]")
+    days = int(((month + np.timedelta64(1, "M")).astype("M8[D]") - first).astype(np.int64))
+    if not 1 <= date.day <= days:
+        raise ValueError(
+            f"{date} of calendar '{calendar}' does not exist in the standard calendar; "
+            "use xarray convert_calendar(..., align_on='date') first"
+        )
+    day_us = int((first + np.timedelta64(date.day - 1, "D")).astype("M8[us]").astype(np.int64))
+    seconds = (date.hour * 60 + date.minute) * 60 + date.second
+    return int(day_us + seconds * US_PER_SECOND + date.microsecond)
+
+
+def _cftime_to_timestamps(flat: np.ndarray[Any, Any], missing: np.ndarray[Any, Any]) -> Any:
+    """cftime dates become datetime64[us] in the standard calendar."""
+    calendars = {item.calendar for item, gap in zip(flat, missing) if not gap}
+    if len(calendars) != 1:
+        raise ValueError(f"cftime dates must have one calendar, got {sorted(calendars)}")
+    (calendar,) = calendars
+    if calendar in REAL_CALENDARS:
+        convert = _elapsed_us
+    elif calendar in MODEL_CALENDARS:
+        convert = _fields_us
+    else:
+        raise ValueError(f"cftime calendar '{calendar}' is not supported")
+    raw = [0 if gap else convert(item, calendar) for item, gap in zip(flat, missing)]
+    return np.array(raw, dtype=np.int64).view("M8[us]")
+
+
+def _encode(values: Any) -> Any:
+    """Object arrays of str or cftime dates become typed arrays. None and NaN become nulls."""
+    values = np.asarray(values)
+    if values.dtype != object:
+        return values
+    flat = values.ravel()
+    missing = np.array([_missing(item) for item in flat], dtype=bool)
+    present = [item for item, gap in zip(flat, missing) if not gap]
+    cftime_type = _cftime_type()
+    if cftime_type is not None and present and all(isinstance(i, cftime_type) for i in present):
+        out = _cftime_to_timestamps(flat, missing)
+    elif all(isinstance(item, str) for item in present):
+        out = np.where(missing, "", flat).astype(str)
+    else:
+        raise TypeError("object arrays must hold only str or cftime dates, with None and NaN")
+    out = out.reshape(values.shape)
+    missing = missing.reshape(values.shape)
+    return np.ma.MaskedArray(out, missing) if missing.any() else out
+
+
+def _attrs(attrs: Mapping[Any, Any]) -> dict[str, Any]:
+    return {_name(key, "attribute"): value for key, value in attrs.items()}
+
+
+def _array(dims: Iterable[Hashable], values: Any, attrs: Mapping[Any, Any]) -> NdArray:
+    names = [_name(dim, "dimension") for dim in dims]
+    return NdArray.from_numpy(_encode(values), dims=names, attrs=_attrs(attrs))
+
+
+def array_to_xarray(array: NdArray, name: str | None = None) -> Any:
+    xr = _xr("NdArray.to_xarray")
+    return xr.DataArray(_decode(array.to_numpy()), dims=array.dims, name=name, attrs=array.attrs)
+
+
+def array_from_xarray(data_array: Any) -> NdArray:
+    xr = _xr("NdArray.from_xarray")
+    if not isinstance(data_array, xr.DataArray):
+        raise TypeError(f"expected an xarray.DataArray, got {type(data_array).__name__}")
+    return _array(data_array.dims, data_array.values, data_array.attrs)
+
+
+def _split(names: Any) -> list[str]:
+    if not isinstance(names, str):
+        raise TypeError(f"the '{COORDINATES}' attribute must be a str, got {names!r}")
+    return names.split()
+
+
+def batch_to_xarray(batch: NdRecordBatch) -> Any:
+    xr = _xr("NdRecordBatch.to_xarray")
+    attrs = batch.attrs
+    coords = set(_split(attrs.pop(COORDINATES, "")))
+    variables = {}
+    for name in batch.keys():
+        array = batch[name]
+        var_attrs = array.attrs
+        coords.update(_split(var_attrs.pop(COORDINATES, "")))
+        if array.dims == (name,):
+            coords.add(name)
+        variables[name] = xr.Variable(array.dims, _decode(array.to_numpy()), attrs=var_attrs)
+    unknown = coords - variables.keys()
+    if unknown:
+        raise ValueError(f"'{COORDINATES}' names columns that do not exist: {sorted(unknown)}")
+    data_vars = {k: v for k, v in variables.items() if k not in coords}
+    coord_vars = {k: v for k, v in variables.items() if k in coords}
+    return xr.Dataset(data_vars, coords=coord_vars, attrs=attrs)
+
+
+def _check_free(attrs: Mapping[str, Any], owner: str) -> None:
+    if COORDINATES in attrs:
+        raise ValueError(
+            f"{owner} has a '{COORDINATES}' attribute; move it to the xarray coordinates"
+        )
+
+
+def batch_from_xarray(dataset: Any) -> NdRecordBatch:
+    xr = _xr("NdRecordBatch.from_xarray")
+    if isinstance(dataset, xr.DataArray):
+        dataset = dataset.to_dataset(name=dataset.name if dataset.name is not None else "data")
+    if not isinstance(dataset, xr.Dataset):
+        raise TypeError(f"expected an xarray.Dataset, got {type(dataset).__name__}")
+
+    # Non-index coordinates go to CF 'coordinates' attributes, as in xarray encoding.
+    extra = [
+        _name(name, "coordinate")
+        for name, coord in dataset.coords.items()
+        if coord.dims != (name,)
+    ]
+    unclaimed = set(extra)
+    columns = {}
+    for key, var in dataset.variables.items():
+        name = _name(key, "variable")
+        attrs = _attrs(var.attrs)
+        _check_free(attrs, f"variable '{name}'")
+        if name in dataset.data_vars:
+            linked = [c for c in extra if set(dataset[c].dims) <= set(var.dims)]
+            if linked:
+                attrs[COORDINATES] = " ".join(linked)
+                unclaimed.difference_update(linked)
+        columns[name] = _array(var.dims, var.values, attrs)
+
+    attrs = _attrs(dataset.attrs)
+    _check_free(attrs, "the dataset")
+    if unclaimed:
+        attrs[COORDINATES] = " ".join(c for c in extra if c in unclaimed)
+    target = {_name(dim, "dimension"): size for dim, size in dataset.sizes.items()}
+    return NdRecordBatch(columns, attrs=attrs, target=target)

nd_arrow_array-0.5.0.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: nd-arrow-array
+Version: 0.5.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
+Requires-Dist: numpy>=1.21
+Requires-Dist: pyarrow>=14 ; extra == 'arrow'
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: pyarrow>=14 ; extra == 'test'
+Requires-Dist: xarray>=2023.1 ; extra == 'test'
+Requires-Dist: cftime>=1.6 ; extra == 'test'
+Requires-Dist: mypy ; extra == 'test'
+Requires-Dist: xarray>=2023.1 ; extra == 'xarray'
+Requires-Dist: cftime>=1.6 ; extra == 'xarray'
+Provides-Extra: arrow
+Provides-Extra: test
+Provides-Extra: xarray
+Summary: N-dimensional Arrow arrays with named dimensions and attributes
+Keywords: arrow,ndarray,xarray,netcdf,tensor
+License: Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/robinskil/nd-arrow-array/blob/main/CHANGELOG.md
+Project-URL: Format, https://github.com/robinskil/nd-arrow-array/blob/main/FORMAT.md
+Project-URL: Repository, https://github.com/robinskil/nd-arrow-array
+
+# nd-arrow-array (Python)
+
+Python bindings for the `nd_arrow.array` Arrow extension type.
+The PyPI package is `nd-arrow-array`. The import name is `nd_arrow_array`.
+The bindings move N-dimensional arrays between NumPy, pyarrow and the
+format in [FORMAT.md](https://github.com/robinskil/nd-arrow-array/blob/main/FORMAT.md).
+
+## Install
+
+```bash
+pip install nd-arrow-array            # NumPy only
+pip install nd-arrow-array[arrow]     # with pyarrow
+pip install nd-arrow-array[xarray]    # with xarray and cftime
+```
+
+To build from source, run `pip install maturin` and `maturin develop` in this directory.
+
+## Classes
+
+| Class | Content |
+|---|---|
+| `NdArray` | One array: values, named dimensions, attributes. |
+| `NdColumn` | An Arrow column. Each row is one `NdArray` or `None`. |
+| `NdRecordBatch` | Named arrays on one shared grid, with global attributes. |
+
+## Example
+
+```python
+import numpy as np
+import nd_arrow_array as nda
+
+a = nda.NdArray.from_numpy(
+    np.arange(6.0).reshape(2, 3),
+    dims=["time", "lat"],
+    attrs={"units": "K", "valid_range": np.array([0, 400], dtype="float32")},
+)
+a.sizes            # {'time': 2, 'lat': 3}
+a.set_attr("long_name", "sea surface temperature")
+a.to_numpy()
+
+col = nda.NdColumn.from_arrays([a, None])
+arr = col.to_arrow()                    # pyarrow array
+nda.NdColumn.from_arrow(arr)[0] == a    # True
+```
+
+## pyarrow
+
+`pip install nd-arrow-array[arrow]` adds pyarrow. pyarrow sees an nd column as a
+`struct` column. The field metadata `ARROW:extension:name = nd_arrow.array`
+marks it as an nd column. See [FORMAT.md](https://github.com/robinskil/nd-arrow-array/blob/main/FORMAT.md).
+
+### Arrays and columns
+
+```python
+import pyarrow as pa
+
+# An array from flat pyarrow values in C order.
+a = nda.NdArray(pa.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]),
+                dims={"time": 2, "lat": 3}, attrs={"units": "K"})
+a.values                         # the flat values as a pyarrow.Array
+
+col = nda.NdColumn.from_arrays([a, None])
+arr = col.to_arrow()             # pyarrow.StructArray, one row per array
+nda.NdColumn.from_arrow(arr)     # back to an NdColumn
+pa.field(col).metadata           # the extension name and version
+```
+
+### Record batches and tables
+
+```python
+lat = nda.NdArray.from_numpy(np.array([-10.0, 0.0, 10.0]), dims=["lat"])
+batch = nda.NdRecordBatch({"sst": a, "lat": lat}, attrs={"title": "demo"})
+
+rb = batch.to_arrow()            # pyarrow.RecordBatch with one row
+table = pa.table(batch)          # pyarrow.Table, through the PyCapsule interface
+
+# Many batches with one schema: one row each.
+rows = nda.encode_batches([batch, other_batch])
+batches = nda.NdRecordBatch.from_arrow(rows)   # a list, one NdRecordBatch per row
+```
+
+`NdRecordBatch.from_arrow` accepts a `RecordBatch`, a `Table` or a
+`RecordBatchReader`. It returns one `NdRecordBatch` for each row.
+The global attributes travel in the `__global_attrs__` column.
+
+### Files
+
+Parquet and Arrow IPC keep the field metadata, so the nd columns survive a
+write and a read:
+
+```python
+import pyarrow.parquet as pq
+
+pq.write_table(pa.Table.from_batches([rows]), "data.parquet")
+batches = nda.NdRecordBatch.from_arrow(pq.read_table("data.parquet"))
+
+with pa.OSFile("data.arrow", "wb") as sink, pa.ipc.new_file(sink, rows.schema) as writer:
+    writer.write_batch(rows)
+with pa.memory_map("data.arrow") as source:
+    batches = nda.NdRecordBatch.from_arrow(pa.ipc.open_file(source).read_all())
+```
+
+### Other libraries
+
+`NdArray`, `NdColumn` and `NdRecordBatch` implement the Arrow PyCapsule
+interface (`__arrow_c_array__`, `__arrow_c_stream__`, `__arrow_c_schema__`).
+pyarrow, polars, DuckDB and other Arrow libraries read them without a copy,
+for example `pa.array(col)` or `pa.table(batch)`.
+
+## xarray
+
+`pip install nd-arrow-array[xarray]` adds xarray and cftime.
+
+```python
+import xarray as xr
+
+ds = xr.Dataset(
+    {"air": (("time", "lat"), np.zeros((2, 3)), {"units": "K"})},
+    coords={"time": np.array(["2020-01-01", "2020-01-02"], "datetime64[ns]"),
+            "lat": [-10.0, 0.0, 10.0]},
+)
+batch = nda.NdRecordBatch.from_xarray(ds)   # all variables and coordinates
+batch.to_xarray()                           # an xarray.Dataset
+
+a = nda.NdArray.from_xarray(ds["air"])      # values, dims and attrs only
+a.to_xarray(name="air")                     # an xarray.DataArray
+```
+
+- `NdRecordBatch.from_xarray` accepts a `Dataset` or a `DataArray`.
+  Each variable and each coordinate becomes a column.
+- A 1-D column with the name of its dimension becomes an index coordinate.
+- Other coordinates go into the CF `coordinates` attribute of the data
+  variables. A coordinate that no data variable uses goes into the
+  `coordinates` attribute of the batch.
+- `NdArray.from_xarray` does not keep coordinates.
+- In `to_xarray`, nulls become `NaN` or `NaT`. Integer and bool arrays with
+  nulls become `float64`, as in xarray CF decoding.
+- Object arrays must hold `str` or cftime dates. `None` and `NaN` become nulls.
+- cftime dates become `timestamp[us]` in the standard calendar:
+  - `standard`, `gregorian`, `proleptic_gregorian` and `julian` keep the
+    exact instant;
+  - `noleap`, `365_day`, `all_leap`, `366_day` and `360_day` keep the year,
+    month, day and time. A date that the standard calendar does not have,
+    such as 30 February, raises `ValueError`. Use
+    `convert_calendar(..., align_on="date")` in xarray first.
+
+## Rules
+
+- NumPy dtypes: `bool`, signed and unsigned integers, `float16`, `float32`,
+  `float64`, `datetime64` and `timedelta64` (`s`, `ms`, `us`, `ns`) and `str`.
+  Other dtypes raise `TypeError`.
+- A `numpy.ma.MaskedArray` mask and `NaT` become nulls. `NaN` stays a value.
+- `to_numpy()` returns a `MaskedArray` when the values have nulls.
+- `attrs` returns a copy. Assign a new dict, or use `set_attr` and `del_attr`.
+- All classes implement the Arrow PyCapsule interface, so pyarrow, polars
+  and DuckDB can read them.
+- The package ships type stubs (`py.typed`), so mypy and pyright check calls.
+
+## Test
+
+```bash
+pip install pytest mypy numpy pyarrow xarray cftime
+maturin develop && pytest
+python -m mypy.stubtest nd_arrow_array          # stubs match the module
+mypy --strict --warn-unused-ignores tests/typing
+```
+

nd_arrow_array-0.5.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+nd_arrow_array/__init__.py,sha256=NxDl4pFD0kpv0QfUDNGzCQExNH6J5O5LCn3KJwUHUbY,335
+nd_arrow_array/_core.pyd,sha256=PuEpvxiVCZ5im9So5oK-6sSrZA81eWWSDxkNp78m_88,10555904
+nd_arrow_array/_core.pyi,sha256=Oeiu__w2OleaMoxHl0jLauVDm0xft-J0vnWpDa8VyCE,5219
+nd_arrow_array/_xarray.py,sha256=hf0GslIzxj4JHFSCbyiAAWANEbsOuMFPo2WyNcdjopA,8963
+nd_arrow_array/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nd_arrow_array-0.5.0.dist-info/METADATA,sha256=GEBvkOanQm-FtJXSe5wUHdHo-zMQncZlRfMV0OCKDsU,7569
+nd_arrow_array-0.5.0.dist-info/WHEEL,sha256=xw8F9xBWUOgm5ym2S9tihj_bLJOb723bjhA0kdANo2I,95
+nd_arrow_array-0.5.0.dist-info/sboms/nd-arrow-py.cyclonedx.json,sha256=0n8ENgBmuTv3M_D62YxIQnwJ_1tsiOAkZU5sJiwqO2U,91585
+nd_arrow_array-0.5.0.dist-info/RECORD,,

nd_arrow_array-0.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.16.0)
+Root-Is-Purelib: false
+Tag: cp39-abi3-win_amd64