labelarray 0.1.0__tar.gz

labelarray-0.1.0/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+## 0.1.0 — 2026-10-25
+
+The first release on its own. labelarray was developed as the array layer
+of tidy3a (`tidy3a.labelarray`) and leaves it unchanged in behaviour:
+
+- `Array`: a NumPy array with named axes, exact labels, attributes, and a
+  name. Selection by positions and labels (`isel`, `sel`), `transpose`,
+  `rename`, reductions (`reduce`), and contraction (`dot`). NumPy's ufuncs,
+  `np.where`, and Python's operators broadcast by axis name under the exact
+  alignment rule.
+- `Collection`: arrays sharing axes, one label array per axis, with
+  selection, assignment, joins (`join`), nearest-label matching
+  (`nearest`), and conversion to and from xarray.
+- The exact label rule (`labels`) and label indexes: sorted, sort-once,
+  and grid indexes, chosen by `index_for`, with `register_index` for other
+  label types.
+- Grouping: `Grouping`, `factorize`, the key transforms `Bins`,
+  `Duration`, `Round`, and `GridCells`, and grouped reductions
+  (`grouped.reduce`, `counts`, `broadcast`) bit-identical to reducing each
+  group on its own.
+- Float32 sums and means correctly rounded in any memory layout (`sums`),
+  with an optional compiled path (`labelarray[fast]`) giving the same bits.
+- One family of errors under `LabelArrayError`.

labelarray-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rigoberto Leyva Salmeron 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

labelarray-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include CHANGELOG.md
+include scripts/check.sh
+recursive-include docs *.md
+recursive-include tests *.py

labelarray-0.1.0/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: labelarray
+Version: 0.1.0
+Summary: Labelled N-D arrays in pure NumPy, with exact label semantics and reproducible reductions
+Author: Rigoberto Leyva Salmeron
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rleyvasal/labelarray
+Keywords: numpy,arrays,labelled arrays,named axes,xarray,reproducibility
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Provides-Extra: xarray
+Requires-Dist: xarray>=2024.6; extra == "xarray"
+Requires-Dist: pandas>=2.2.2; extra == "xarray"
+Provides-Extra: fast
+Requires-Dist: numba>=0.60; extra == "fast"
+Provides-Extra: dev
+Requires-Dist: xarray>=2024.6; extra == "dev"
+Requires-Dist: pandas>=2.2.2; extra == "dev"
+Requires-Dist: numba>=0.60; extra == "dev"
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# labelarray
+
+Labelled N-D arrays in pure NumPy, with exact label semantics and
+reproducible reductions. It needs NumPy only; xarray is used only to convert
+to and from xarray objects. It is the array layer of
+[tidy3a](https://github.com/rleyvasal/tidy3a), released on its own.
+
+It is deliberately small. What it offers that other array libraries do not:
+
+1. **Exact labels.** Labels match only when they are the same kind
+   (booleans, numbers, times, durations, text, bytes) and exactly equal, in
+   lookups, alignment, and joins. The integer `2**53 + 1` never matches the
+   float `2**53`; pandas, and so xarray, pair labels through float64.
+2. **Reproducible reductions.** Float32 sums and means are correctly
+   rounded: the float32 nearest the exact result, the same in any memory
+   layout. Grouped reductions are bit-identical to reducing each group on
+   its own.
+3. **Collections.** Arrays sharing axes, with one label array per axis,
+   joined and aligned under those rules.
+
+**Status:** version `0.1.0`, the first release on its own; the API may still
+change before 1.0. What changed in each release is in
+[CHANGELOG.md](CHANGELOG.md).
+
+## Installing
+
+Requires Python 3.11 or newer.
+
+```bash
+pip install labelarray                  # NumPy only
+pip install "labelarray[xarray]"        # with xarray: to_xarray() and from_xarray()
+pip install "labelarray[fast]"          # with Numba: compiled grouped float32 sums and means
+```
+
+Results are the same with or without `fast`; it only makes large grouped
+sums and means faster.
+
+## Arrays
+
+An `Array` is a NumPy array with one name per axis, labels for any of its
+axes, attributes, and a name:
+
+```python
+import numpy as np
+from labelarray import Array
+
+air = Array(
+    np.array([[271.0, 272.0, 273.0], [281.0, 282.0, 283.0]], dtype="float32"),
+    dims=("lat", "time"),
+    coords={"lat": [10.0, 20.0], "time": np.arange("2026-01-01", "2026-01-04", dtype="datetime64[D]")},
+    attrs={"units": "K"},
+    name="air",
+)
+print(air.sel(lat=20.0).data)  # [281. 282. 283.]
+print(air.isel(time=[0, 2]).labels("time"))  # ['2026-01-01' '2026-01-03']
+print(air.reduce("mean", ["time"]).data)  # [272. 282.]
+```
+
+`isel` takes positions, slices, or masks; `sel` takes labels, looked up
+exactly; one label or position removes the axis, a list keeps it.
+`transpose`, `rename` (axes), `reduce` (sum, mean, min, max, median, std,
+var, any, all, count, with `na_rm` and `min_count`), and `dot` (the sum of
+products over named axes) complete the methods.
+
+NumPy's ufuncs, `np.where`, and Python's operators broadcast by axis name.
+Labels on a shared axis must match: the same labels in another order are
+matched by label, and anything else is an `AlignError`. There is no outer
+join by default; ask for one with `Collection.join`.
+
+```python
+import numpy as np
+from labelarray import Array
+
+a = Array([1.0, 2.0, 3.0], ("x",), {"x": [1, 2, 3]})
+b = Array([30.0, 10.0, 20.0], ("x",), {"x": [3, 1, 2]})
+print((a + b).data)  # [11. 22. 33.]
+print(np.sqrt(a * 4).data)  # [2.         2.82842712 3.46410162]
+```
+
+Labels are copied once into a read-only array the library owns, and each
+label array's index is built on first use and kept with it: a sorted index,
+a sort-once index for unsorted labels, or a grid index for evenly spaced
+numbers and times, which looks labels up arithmetically. `register_index`
+adds index classes for other label types, under the same exactness
+obligations.
+
+## Collections
+
+A `Collection` holds variables with different axes, each axis with one size
+and at most one label array:
+
+```python
+from labelarray import Array, Collection
+
+left = Collection({"a": Array([1.0, 2.0, 3.0], ("k",))}, {"k": [1, 3, 5]})
+right = Collection({"b": Array([10.0, 20.0], ("k",))}, {"k": [5, 1]})
+both = left.join(right, "inner")
+print(both.coords["k"])  # [1 5]
+print(both.array("b").data)  # [20. 10.]
+print(left.join(right, "left").array("b").data)  # [20. nan 10.]
+```
+
+`isel`, `sel`, `select` (variables), `assign`, `rename` (variables), `join`
+(left, inner, or outer), `nearest` (each label matched to its nearest within
+a tolerance), `to_dict`, `to_xarray`, and `from_xarray` are its methods.
+Missing positions after a join promote integers and booleans as xarray
+does, and attributes that conflict are dropped.
+
+## Grouping
+
+A `Grouping` assigns each position a group code; `factorize` makes one from
+key values, optionally after a key transform (`Bins`, `Duration`, `Round`,
+`GridCells`), with every missing key (NaN, NaT) one group, dropped unless
+asked for. `grouped.reduce` reduces every group at once:
+
+```python
+import numpy as np
+from labelarray import Array, Grouping, factorize, grouped
+
+intensity = Array(np.array([10, 20, 30, 40, 50], dtype="float32"), ("point",))
+codes, labels = factorize(np.array([0, 0, 1, 1, 2]))
+rings = Grouping(codes, labels)
+print(grouped.reduce(intensity, "mean", rings, "point", "ring").data)  # [15. 35. 50.]
+print(grouped.counts(rings, "ring").data)  # [2 2 1]
+```
+
+`grouped.broadcast` puts a result per group back on each position.
+
+## Errors
+
+Every error is a `LabelArrayError` (a `ValueError`): `LabelError` for labels
+that cannot be found, ordered, or compared; `AlignError` for axes that
+cannot be paired; `GroupError` for keys that cannot be grouped; and
+`ShapeError` for axis names, sizes, and ranks that do not fit.
+
+## Development
+
+From a checkout, install the development dependencies and run the tests:
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest -q
+```
+
+xarray and pandas are test dependencies: the tests check the library against
+xarray and its label lookups against pandas. Before pushing, run the CI
+checks in fresh environments with only declared dependencies (requires
+[uv](https://docs.astral.sh/uv/)):
+
+```bash
+scripts/check.sh
+```
+
+The [release procedure](docs/releasing.md) describes the GitHub Release
+workflow.
+
+## License
+
+MIT

labelarray-0.1.0/README.md

@@ -0,0 +1,159 @@
+# labelarray
+
+Labelled N-D arrays in pure NumPy, with exact label semantics and
+reproducible reductions. It needs NumPy only; xarray is used only to convert
+to and from xarray objects. It is the array layer of
+[tidy3a](https://github.com/rleyvasal/tidy3a), released on its own.
+
+It is deliberately small. What it offers that other array libraries do not:
+
+1. **Exact labels.** Labels match only when they are the same kind
+   (booleans, numbers, times, durations, text, bytes) and exactly equal, in
+   lookups, alignment, and joins. The integer `2**53 + 1` never matches the
+   float `2**53`; pandas, and so xarray, pair labels through float64.
+2. **Reproducible reductions.** Float32 sums and means are correctly
+   rounded: the float32 nearest the exact result, the same in any memory
+   layout. Grouped reductions are bit-identical to reducing each group on
+   its own.
+3. **Collections.** Arrays sharing axes, with one label array per axis,
+   joined and aligned under those rules.
+
+**Status:** version `0.1.0`, the first release on its own; the API may still
+change before 1.0. What changed in each release is in
+[CHANGELOG.md](CHANGELOG.md).
+
+## Installing
+
+Requires Python 3.11 or newer.
+
+```bash
+pip install labelarray                  # NumPy only
+pip install "labelarray[xarray]"        # with xarray: to_xarray() and from_xarray()
+pip install "labelarray[fast]"          # with Numba: compiled grouped float32 sums and means
+```
+
+Results are the same with or without `fast`; it only makes large grouped
+sums and means faster.
+
+## Arrays
+
+An `Array` is a NumPy array with one name per axis, labels for any of its
+axes, attributes, and a name:
+
+```python
+import numpy as np
+from labelarray import Array
+
+air = Array(
+    np.array([[271.0, 272.0, 273.0], [281.0, 282.0, 283.0]], dtype="float32"),
+    dims=("lat", "time"),
+    coords={"lat": [10.0, 20.0], "time": np.arange("2026-01-01", "2026-01-04", dtype="datetime64[D]")},
+    attrs={"units": "K"},
+    name="air",
+)
+print(air.sel(lat=20.0).data)  # [281. 282. 283.]
+print(air.isel(time=[0, 2]).labels("time"))  # ['2026-01-01' '2026-01-03']
+print(air.reduce("mean", ["time"]).data)  # [272. 282.]
+```
+
+`isel` takes positions, slices, or masks; `sel` takes labels, looked up
+exactly; one label or position removes the axis, a list keeps it.
+`transpose`, `rename` (axes), `reduce` (sum, mean, min, max, median, std,
+var, any, all, count, with `na_rm` and `min_count`), and `dot` (the sum of
+products over named axes) complete the methods.
+
+NumPy's ufuncs, `np.where`, and Python's operators broadcast by axis name.
+Labels on a shared axis must match: the same labels in another order are
+matched by label, and anything else is an `AlignError`. There is no outer
+join by default; ask for one with `Collection.join`.
+
+```python
+import numpy as np
+from labelarray import Array
+
+a = Array([1.0, 2.0, 3.0], ("x",), {"x": [1, 2, 3]})
+b = Array([30.0, 10.0, 20.0], ("x",), {"x": [3, 1, 2]})
+print((a + b).data)  # [11. 22. 33.]
+print(np.sqrt(a * 4).data)  # [2.         2.82842712 3.46410162]
+```
+
+Labels are copied once into a read-only array the library owns, and each
+label array's index is built on first use and kept with it: a sorted index,
+a sort-once index for unsorted labels, or a grid index for evenly spaced
+numbers and times, which looks labels up arithmetically. `register_index`
+adds index classes for other label types, under the same exactness
+obligations.
+
+## Collections
+
+A `Collection` holds variables with different axes, each axis with one size
+and at most one label array:
+
+```python
+from labelarray import Array, Collection
+
+left = Collection({"a": Array([1.0, 2.0, 3.0], ("k",))}, {"k": [1, 3, 5]})
+right = Collection({"b": Array([10.0, 20.0], ("k",))}, {"k": [5, 1]})
+both = left.join(right, "inner")
+print(both.coords["k"])  # [1 5]
+print(both.array("b").data)  # [20. 10.]
+print(left.join(right, "left").array("b").data)  # [20. nan 10.]
+```
+
+`isel`, `sel`, `select` (variables), `assign`, `rename` (variables), `join`
+(left, inner, or outer), `nearest` (each label matched to its nearest within
+a tolerance), `to_dict`, `to_xarray`, and `from_xarray` are its methods.
+Missing positions after a join promote integers and booleans as xarray
+does, and attributes that conflict are dropped.
+
+## Grouping
+
+A `Grouping` assigns each position a group code; `factorize` makes one from
+key values, optionally after a key transform (`Bins`, `Duration`, `Round`,
+`GridCells`), with every missing key (NaN, NaT) one group, dropped unless
+asked for. `grouped.reduce` reduces every group at once:
+
+```python
+import numpy as np
+from labelarray import Array, Grouping, factorize, grouped
+
+intensity = Array(np.array([10, 20, 30, 40, 50], dtype="float32"), ("point",))
+codes, labels = factorize(np.array([0, 0, 1, 1, 2]))
+rings = Grouping(codes, labels)
+print(grouped.reduce(intensity, "mean", rings, "point", "ring").data)  # [15. 35. 50.]
+print(grouped.counts(rings, "ring").data)  # [2 2 1]
+```
+
+`grouped.broadcast` puts a result per group back on each position.
+
+## Errors
+
+Every error is a `LabelArrayError` (a `ValueError`): `LabelError` for labels
+that cannot be found, ordered, or compared; `AlignError` for axes that
+cannot be paired; `GroupError` for keys that cannot be grouped; and
+`ShapeError` for axis names, sizes, and ranks that do not fit.
+
+## Development
+
+From a checkout, install the development dependencies and run the tests:
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest -q
+```
+
+xarray and pandas are test dependencies: the tests check the library against
+xarray and its label lookups against pandas. Before pushing, run the CI
+checks in fresh environments with only declared dependencies (requires
+[uv](https://docs.astral.sh/uv/)):
+
+```bash
+scripts/check.sh
+```
+
+The [release procedure](docs/releasing.md) describes the GitHub Release
+workflow.
+
+## License
+
+MIT

labelarray-0.1.0/docs/releasing.md

@@ -0,0 +1,51 @@
+# Releasing labelarray
+
+The release workflow is `.github/workflows/release.yml`. Publishing a GitHub
+Release starts it. It requires a tag matching the package version, runs the
+reusable CI checks on that commit, then publishes the same source archive
+and wheel that passed metadata and clean-install checks. The publishing job
+downloads those artifacts without rebuilding them.
+
+## One-time setup
+
+In `rleyvasal/labelarray`, create a GitHub environment named `pypi` (done
+2026-10-25, with no protection rules). Release restrictions and required
+reviewers can be added in the repository settings later; naming the
+environment in YAML does not itself configure approval rules.
+
+Register a PyPI trusted publisher with these values:
+
+| Field | Value |
+|---|---|
+| PyPI project | `labelarray` |
+| GitHub owner | `rleyvasal` |
+| GitHub repository | `labelarray` |
+| Workflow filename | `release.yml` |
+| GitHub environment | `pypi` |
+
+For a new project, use a [pending publisher](https://docs.pypi.org/trusted-publishers/creating-a-project-through-oidc/).
+For an existing project you manage, [add the publisher to that project](https://docs.pypi.org/trusted-publishers/adding-a-publisher/).
+The workflow uses [trusted publishing](https://docs.pypi.org/trusted-publishers/using-a-publisher/)
+with a short-lived identity token; no saved PyPI API token is required.
+
+The PyPI publisher was registered as a pending publisher on 2026-10-25;
+the first successful release creates the project.
+
+## Prepare and publish a version
+
+1. Set `src/labelarray/__version__.py` to the release version, for example
+   `0.1.0`. The workflow rejects development versions such as `0.1.0.dev0`.
+2. Move the release's changelog entries under a version-and-date heading.
+   Update the README and first-release notes for the published version.
+3. Run `scripts/check.sh`.
+4. Commit the release changes and push them. Create the corresponding
+   version tag, for example `v0.1.0`, on that commit and push the tag.
+5. Publish a GitHub Release for the tag. This triggers the version check,
+   Python 3.11–3.14 tests, minimum-dependency tests, and distribution checks.
+6. Approve the `pypi` environment deployment if its configured rules require
+   approval. Confirm the publishing job succeeds and verify the version
+   listed on [PyPI](https://pypi.org/project/labelarray/).
+
+If a check fails, the publishing job does not run. Fix the failure before
+releasing. After a successful upload, PyPI does not allow replacing that
+version's files; subsequent changes need a new version.

labelarray-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=77.0.3", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "labelarray"
+dynamic = ["version"]
+description = "Labelled N-D arrays in pure NumPy, with exact label semantics and reproducible reductions"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Rigoberto Leyva Salmeron" }]
+keywords = ["numpy", "arrays", "labelled arrays", "named axes", "xarray", "reproducibility"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering",
+]
+# NumPy 2's promotion rules are assumed throughout. NumPy is the only requirement.
+dependencies = [
+  "numpy>=2.0",
+]
+
+[project.optional-dependencies]
+# to_xarray() and from_xarray(). 2.2.2 is the first pandas built for NumPy 2;
+# older wheels fail to import alongside numpy>=2.0.
+xarray = ["xarray>=2024.6", "pandas>=2.2.2"]
+# Compiled grouped float32 sums and means (labelarray.sums); the same results as without it, faster.
+# 0.60 is the first Numba release for NumPy 2.0. Numba supports a new NumPy some months after it appears.
+fast = ["numba>=0.60"]
+# xarray and pandas: the references the tests compare with.
+# numba: the tests run the compiled path; the minimum-dependency job runs the NumPy path.
+dev = ["xarray>=2024.6", "pandas>=2.2.2", "numba>=0.60", "pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://github.com/rleyvasal/labelarray"
+
+[tool.setuptools.dynamic]
+version = { attr = "labelarray.__version__.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+labelarray = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

labelarray-0.1.0/scripts/check.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# Run what CI runs (.github/workflows/tests.yml), locally, before pushing.
+#
+# Each job gets a fresh environment with only labelarray's declared
+# dependencies, so nothing installed on this machine (a newer xarray, tidy3a)
+# can hide a failure that CI would see.
+#
+#   scripts/check.sh            all jobs
+#   scripts/check.sh 3.12       one Python version only
+#
+# Needs uv (https://docs.astral.sh/uv/); it downloads missing Pythons.
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+work="$(mktemp -d)"
+trap 'rm -rf "$work"' EXIT
+
+versions=("${@:-3.11 3.12 3.13 3.14}")
+versions=(${versions[@]})
+failed=()
+
+run() {
+  local name="$1"; shift
+  printf '\n── %s ──\n' "$name"
+  if "$@"; then
+    printf '   ok: %s\n' "$name"
+  else
+    printf '   FAILED: %s\n' "$name"
+    failed+=("$name")
+  fi
+}
+
+pytest_job() {
+  local python="$1"; shift
+  local env="$work/py$python-$RANDOM"
+  uv venv -q --python "$python" "$env" &&
+    uv pip install -q --python "$env/bin/python" "$@" &&
+    "$env/bin/python" -m pytest -q -p no:cacheprovider
+}
+
+for python in "${versions[@]}"; do
+  run "pytest (Python $python)" pytest_job "$python" -e ".[dev]"
+done
+
+if [[ $# -eq 0 ]]; then
+  run "pytest (minimum NumPy and xarray)" \
+    pytest_job 3.11 "numpy==2.0.*" "pandas==2.2.2" "xarray==2024.6.0" pytest -e .
+
+  distribution_job() {
+    uv build -q --out-dir "$work/dist" &&
+      uvx twine check --strict "$work"/dist/* &&
+      uv venv -q --python 3.12 "$work/clean" &&
+      uv pip install -q --python "$work/clean/bin/python" "$work"/dist/*.whl &&
+      (cd "$work" && "$work/clean/bin/python" -c \
+        "import labelarray, numpy as np; a = labelarray.Array(np.arange(3.0), ('t',), {'t': [1, 2, 3]}); print(a.sel(t=2).data, labelarray.__version__)") &&
+      uv venv -q --python 3.12 "$work/full" &&
+      uv pip install -q --python "$work/full/bin/python" "$(ls "$work"/dist/*.whl)[xarray]" &&
+      (cd "$work" && "$work/full/bin/python" -c \
+        "import labelarray, numpy as np; a = labelarray.Array(np.arange(3.0), ('t',), {'t': [1, 2, 3]}); print(labelarray.Collection({'a': a}, a.coords).to_xarray())") &&
+      uv venv -q --python 3.12 "$work/fast" &&
+      uv pip install -q --python "$work/fast/bin/python" "$(ls "$work"/dist/*.whl)[fast]" &&
+      (cd "$work" && "$work/fast/bin/python" -c \
+        "import numpy as np; from labelarray import sums; v = np.ones(200_000, np.float32); assert sums._compiled('grouped_estimate') is not None, 'compiled kernel not loaded'; print(sums.reduce(v, 'mean', (0,), codes=np.zeros(200_000, np.intp), groups=1))")
+  }
+  run "source distribution, metadata, and installed wheel (plain, with the xarray extra, and with the fast extra)" distribution_job
+fi
+
+printf '\n'
+if [[ ${#failed[@]} -gt 0 ]]; then
+  printf 'FAILED: %s\n' "${failed[@]}"
+  exit 1
+fi
+printf 'All checks passed; safe to push.\n'

labelarray-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

labelarray-0.1.0/src/labelarray/__init__.py

@@ -0,0 +1,82 @@
+"""labelarray: labelled N-D arrays in NumPy, with exact labels and reproducible reductions.
+
+The public API:
+
+- ``Array``: a NumPy array with named axes, exact labels, attributes, and a
+  name; NumPy's ufuncs, ``np.where``, and Python's operators broadcast by axis
+  name. ``Collection``: arrays sharing axes, one label array per axis.
+  ``concat``, ``align``, and ``broadcast`` work on several arrays (``array``,
+  ``collection``).
+- The exact label rule: ``kind``, ``equal``, ``compare``, ``strict_subset``,
+  ``exact_cast``, ``lossy_join_type`` (``labels``); label indexes and their
+  factory, ``index_for`` and ``register_index`` (``index``).
+- Grouping: ``Grouping``, with ``reduce``, ``counts``, and ``broadcast``
+  applying it to an array (``grouped``); ``factorize`` and the key transforms
+  ``Bins``, ``Duration``, ``Round``, and ``GridCells`` (``transforms``).
+- Numbers: float32 sums and means correctly rounded (``sums``) and the
+  contraction behind ``Array.dot`` (``contract``).
+- Errors: ``LabelArrayError`` and its ``LabelError``, ``AlignError``,
+  ``GroupError``, and ``ShapeError`` (``errors``).
+"""
+
+from labelarray.__version__ import __version__
+from labelarray.array import Array, align, broadcast, concat, label_index
+from labelarray.collection import Collection
+from labelarray.errors import (
+    AlignError,
+    GroupError,
+    LabelArrayError,
+    LabelError,
+    ShapeError,
+)
+from labelarray.grouped import Grouping
+from labelarray.index import (
+    GridIndex,
+    LabelIndex,
+    SortedIndex,
+    SortOnceIndex,
+    index_for,
+    register_index,
+)
+from labelarray.labels import (
+    compare,
+    equal,
+    exact_cast,
+    kind,
+    lossy_join_type,
+    strict_subset,
+)
+from labelarray.transforms import Bins, Duration, GridCells, Round, factorize
+
+__all__ = [
+    "AlignError",
+    "Array",
+    "Bins",
+    "Collection",
+    "Duration",
+    "GridCells",
+    "GridIndex",
+    "GroupError",
+    "Grouping",
+    "LabelArrayError",
+    "LabelError",
+    "LabelIndex",
+    "Round",
+    "ShapeError",
+    "SortOnceIndex",
+    "SortedIndex",
+    "__version__",
+    "align",
+    "broadcast",
+    "compare",
+    "concat",
+    "equal",
+    "exact_cast",
+    "factorize",
+    "index_for",
+    "kind",
+    "label_index",
+    "lossy_join_type",
+    "register_index",
+    "strict_subset",
+]

labelarray-0.1.0/src/labelarray/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"