xarray-ms 0.5.1__tar.gz → 0.5.4__tar.gz

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/.github/workflows/ci.yml

@@ -30,42 +30,7 @@ jobs:
       fail-fast: false
       matrix:
         os: ["ubuntu-22.04", "macos-13", "macos-14", "macos-15"]
-        python-version: ["3.10", "3.11", "3.12", "3.13"]
-        is_main_or_release:
-          - ${{ contains(github.ref, 'main') || startsWith(github.ref, 'refs/tags')}}
-        exclude:
-          # Don't test on macos-{13,14} in PR's
-          - is_main_or_release: false
-            os: "macos-13"
-          - is_main_or_release: false
-            os: "macos-14"
-          # Don't test on 3.10 - 3.12 in PR's
-          - is_main_or_release: false
-            python-version: "3.10"
-          - is_main_or_release: false
-            python-version: "3.11"
-          - is_main_or_release: false
-            python-version: "3.12"
-          # Don't test on macos on 3.10 - 3.12 in PRs
-          - os: "macos-13"
-            python-version: "3.10"
-          - os: "macos-13"
-            python-version: "3.11"
-          - os: "macos-13"
-            python-version: "3.12"
-          - os: "macos-14"
-            python-version: "3.10"
-          - os: "macos-14"
-            python-version: "3.11"
-          - os: "macos-14"
-            python-version: "3.12"
-          - os: "macos-15"
-            python-version: "3.10"
-          - os: "macos-15"
-            python-version: "3.11"
-          - os: "macos-15"
-            python-version: "3.12"
-
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
 
     steps:
       - name: Set up Python ${{ matrix.python-version }}

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: xarray-ms
-Version: 0.5.1
+Version: 0.5.4
 Summary: xarray MSv4 views over MSv2 Measurement Sets
 Author-email: Simon Perkins <simon.perkins@gmail.com>
 License-File: LICENSE
-Requires-Python: >=3.10
-Requires-Dist: arcae<0.4.0,>=0.3.2
+Requires-Python: >=3.11
+Requires-Dist: arcae<0.6.0,>=0.5.1
 Requires-Dist: cacheout>=0.16.0
 Requires-Dist: typing-extensions>=4.12.2
 Requires-Dist: xarray>=2025.0

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/doc/source/changelog.rst

@@ -3,6 +3,19 @@
 Changelog
 =========
 
+0.5.4 (20-05-2026)
+------------------
+* Allow unsupported arguments in entrypoint methods (:pr:`154`)
+
+0.5.3 (11-05-2026)
+------------------
+* Expand standard msv2 columns supported during reads (:pr:`153`)
+* Handle duplicate antenna name (:pr:`151`)
+* Deprecate python 3.10 support (:pr:`150`)
+* Add python 3.14 to CI testing matrix (:pr:`150`)
+* Test more comprehensively in pull requests (:pr:`150`)
+* Depend on arcae ``>= 0.5.1, < 0.6.0`` (:pr:`149`)
+
 0.5.1 (06-03-2026)
 ------------------
 * Correct ``BroadcastMSv2Array`` initialisation of ``MSv2Array`` base class

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/doc/source/conf.py

@@ -11,7 +11,7 @@
 project = "xarray-ms"
 copyright = "2024 - 2025 NRF (SARAO) and Rhodes University (RATT) Centre"
 author = "Simon Perkins"
-release = "0.5.1"
+release = "0.5.4"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "xarray-ms"
-version = "0.5.1"
+version = "0.5.4"
 description = "xarray MSv4 views over MSv2 Measurement Sets"
 authors = [{name = "Simon Perkins", email = "simon.perkins@gmail.com"}]
 readme = "README.rst"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dependencies = [
     "xarray>=2025.0",
     "cacheout>=0.16.0",
-    "arcae>=0.3.2, < 0.4.0",
+    "arcae>=0.5.1, < 0.6.0",
     "typing-extensions>=4.12.2",
 ]
 
@@ -55,7 +55,7 @@ extend-select = ["I"]
 # github_url = "https://github.com/<user or organization>/<project>/"
 
 [tool.tbump.version]
-current = "0.5.1"
+current = "0.5.4"
 
 # Example of a semver regexp.
 # Make sure this matches current_version before
@@ -77,9 +77,11 @@ tag_template = "{new_version}"
 # tbump.toml location.
 [[tool.tbump.file]]
 src = "pyproject.toml"
+search = 'version = "{current_version}"'
 
 [[tool.tbump.file]]
 src = "doc/source/conf.py"
+search = 'release = "{current_version}"'
 
 # You can specify a list of commands to
 # run after the files have been patched

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/tests/test_antenna.py

@@ -4,6 +4,8 @@ import pytest
 import xarray
 from arcae.lib.arrow_tables import Table, ms_descriptor
 
+from xarray_ms.errors import DuplicateAntennaNameWarning
+
 NANTENNA = 6
 
 
@@ -138,3 +140,60 @@ def test_antenna_feed_join(simmed_ms, auto_corrs):
   npt.assert_array_equal(
     p1["antenna_xds"].antenna_name, np.array(["ANTENNA-0", "ANTENNA-2"], dtype=object)
   )
+
+
+@pytest.mark.parametrize(
+  "simmed_ms",
+  [{"name": "dup.ms", "nantenna": 3, "auto_corrs": True}],
+  indirect=True,
+)
+def test_duplicate_antenna_names(simmed_ms):
+  """When ANTENNA::NAME contains duplicates, names are made unique and a
+  warning is emitted.  The names in antenna_xds and the baseline coordinate
+  must be consistent with each other."""
+
+  # Overwrite ANTENNA::NAME so that antenna 0 and antenna 1 share a name.
+  with Table.from_filename(f"{simmed_ms}::ANTENNA") as T:
+    T.putcol("NAME", np.asarray(["SAME", "SAME", "OTHER"]))
+
+  with pytest.warns(DuplicateAntennaNameWarning, match="SAME"):
+    dt = xarray.open_datatree(simmed_ms, auto_corrs=True).load()
+
+  partition = dt[list(dt.children)[0]]
+  antenna_xds = partition["antenna_xds"]
+
+  # All antenna_name coordinate values must be unique
+  ant_names = antenna_xds.antenna_name.values
+  assert len(ant_names) == len(set(ant_names)), "antenna_name coordinate has duplicates"
+
+  # Duplicated base names get -N suffixes; unique names are unchanged
+  assert "SAME-1" in ant_names
+  assert "SAME-2" in ant_names
+  assert "OTHER" in ant_names
+
+  # correlated dataset baseline_antenna{i}_name maps
+  # appropriately to the antenna dataset antenna names.
+  concat_ant_names = np.concatenate(
+    [partition.baseline_antenna1_name, partition.baseline_antenna2_name]
+  )
+  unique_ant_names, inv = np.unique(concat_ant_names, return_inverse=True)
+  _, lookup = np.where(unique_ant_names[:, None] == ant_names[None, :])
+  ant1 = lookup[inv[: len(inv) // 2]]
+  ant2 = lookup[inv[len(inv) // 2 :]]
+
+  np.testing.assert_array_equal(partition.baseline_antenna1_name, ant_names[ant1])
+  np.testing.assert_array_equal(partition.baseline_antenna2_name, ant_names[ant2])
+
+
+@pytest.mark.parametrize(
+  "simmed_ms",
+  [{"name": "nodup.ms", "nantenna": 3, "auto_corrs": True}],
+  indirect=True,
+)
+def test_unique_antenna_names_no_warning(simmed_ms):
+  """When all antenna names are already unique no warning should be emitted."""
+  import warnings
+
+  with warnings.catch_warnings():
+    warnings.simplefilter("error", DuplicateAntennaNameWarning)
+    xarray.open_datatree(simmed_ms, auto_corrs=True).load()

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/tests/test_backend.py

@@ -7,6 +7,7 @@ import xarray.testing as xt
 from numpy.testing import assert_array_equal
 
 from xarray_ms.backend.msv2.entrypoint import MSv2EntryPoint
+from xarray_ms.errors import IgnoredArgument
 from xarray_ms.testing.utils import id_string, prune_datetime_structures
 
 
@@ -237,3 +238,14 @@ def test_open_datatree_chunking(simmed_ms):
   }
 
   assert ncdt.identical(prune_datetime_structures(dt))
+
+
+@pytest.mark.parametrize(
+  "simmed_ms",
+  [{"name": "ignored_kwargs.ms"}],
+  indirect=True,
+)
+def test_ignored_kwargs_warning(simmed_ms):
+  with pytest.warns(IgnoredArgument, match="unsupported_kwarg"):
+    dt = xarray.open_datatree(simmed_ms, unsupported_kwarg=True)
+  assert isinstance(dt, xarray.DataTree)

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/tests/test_read.py

@@ -415,6 +415,30 @@ NONSTANDARD_TABLE_DESC = {
     # 'shape': ...,  # Variably shaped
     "valueType": "COMPLEX",
   },
+  "MODEL_DATA": {
+    "_c_order": True,
+    "comment": "MODEL_DATA column",
+    "dataManagerGroup": "StandardStMan",
+    "dataManagerType": "StandardStMan",
+    "keywords": {},
+    "maxlen": 0,
+    "ndim": 2,
+    "option": 0,
+    # 'shape': ...,  # Variably shaped
+    "valueType": "COMPLEX",
+  },
+  "FLOAT_DATA": {
+    "_c_order": True,
+    "comment": "FLOAT_DATA column",
+    "dataManagerGroup": "StandardStMan",
+    "dataManagerType": "StandardStMan",
+    "keywords": {},
+    "maxlen": 0,
+    "ndim": 2,
+    "option": 0,
+    # 'shape': ...,  # Variably shaped
+    "valueType": "FLOAT",
+  },
   "CORRELATED_WEIGHT_SPECTRUM": {
     "_c_order": True,
     "comment": "CORRELATED_WEIGHT_SPECTRUM column",
@@ -432,6 +456,8 @@ NONSTANDARD_TABLE_DESC = {
 
 def _add_non_standard_columns(chunk_desc, data_dict):
   data_dict["CORRELATED_DATA"] = data_dict["DATA"]
+  data_dict["MODEL_DATA"] = data_dict["DATA"]
+  data_dict["FLOAT_DATA"] = (data_dict["DATA"][0], data_dict["DATA"][1].real)
   return data_dict
 
 
@@ -463,3 +489,18 @@ def test_additional_columns(simmed_ms):
         "polarization",
       )
       assert node["CORRELATED_DATA"].equals(node["VISIBILITY"])
+      assert node["FLOAT_DATA"].dims == (
+        "time",
+        "baseline_id",
+        "frequency",
+        "polarization",
+      )
+      assert node["FLOAT_DATA"].equals(node["VISIBILITY"].real)
+
+      assert node["MODEL_DATA"].dims == (
+        "time",
+        "baseline_id",
+        "frequency",
+        "polarization",
+      )
+      assert node["MODEL_DATA"].equals(node["VISIBILITY"])

xarray_ms-0.5.4/tests/test_table_utils.py

@@ -0,0 +1,89 @@
+import warnings
+
+import numpy as np
+import numpy.testing as npt
+import pytest
+
+from xarray_ms.backend.msv2.table_utils import unique_antenna_names
+from xarray_ms.errors import DuplicateAntennaNameWarning
+
+
+def test_all_unique_no_change():
+  names = np.array(["A", "B", "C"])
+  result = unique_antenna_names(names)
+  npt.assert_array_equal(result, names)
+
+
+def test_all_unique_no_warning():
+  names = np.array(["A", "B", "C"])
+  with warnings.catch_warnings():
+    warnings.simplefilter("error", DuplicateAntennaNameWarning)
+    unique_antenna_names(names)  # should not raise
+
+
+def test_two_duplicates():
+  names = np.array(["A", "A", "B"])
+  with pytest.warns(DuplicateAntennaNameWarning):
+    result = unique_antenna_names(names)
+  npt.assert_array_equal(result, ["A-1", "A-2", "B"])
+
+
+def test_triple_duplicate():
+  names = np.array(["A", "A", "A"])
+  with pytest.warns(DuplicateAntennaNameWarning):
+    result = unique_antenna_names(names)
+  npt.assert_array_equal(result, ["A-1", "A-2", "A-3"])
+
+
+def test_non_contiguous_duplicates():
+  names = np.array(["A", "B", "A", "C", "A"])
+  with pytest.warns(DuplicateAntennaNameWarning):
+    result = unique_antenna_names(names)
+  npt.assert_array_equal(result, ["A-1", "B", "A-2", "C", "A-3"])
+
+
+def test_unique_name_unchanged_when_mixed():
+  names = np.array(["X", "Y", "X"])
+  with pytest.warns(DuplicateAntennaNameWarning):
+    result = unique_antenna_names(names)
+  npt.assert_array_equal(result, ["X-1", "Y", "X-2"])
+
+
+def test_underscore_in_base_name():
+  """Dash separator avoids collision with names already containing underscores."""
+  names = np.array(["ANTENNA_1", "ANTENNA_1"])
+  with pytest.warns(DuplicateAntennaNameWarning):
+    result = unique_antenna_names(names)
+  npt.assert_array_equal(result, ["ANTENNA_1-1", "ANTENNA_1-2"])
+
+
+def test_empty_array():
+  names = np.array([], dtype=str)
+  result = unique_antenna_names(names)
+  npt.assert_array_equal(result, [])
+
+
+def test_single_element():
+  names = np.array(["A"])
+  result = unique_antenna_names(names)
+  npt.assert_array_equal(result, ["A"])
+
+
+def test_warning_raised_on_duplicates():
+  names = np.array(["A", "A", "B"])
+  with pytest.warns(DuplicateAntennaNameWarning, match="Duplicate antenna names"):
+    unique_antenna_names(names)
+
+
+def test_warning_lists_duplicate_names():
+  names = np.array(["FOO", "BAR", "FOO"])
+  with pytest.warns(DuplicateAntennaNameWarning, match="FOO"):
+    unique_antenna_names(names)
+
+
+def test_result_is_always_unique():
+  """Output names must all be distinct regardless of input."""
+  names = np.array(["A", "A", "B", "B", "C"])
+  with pytest.warns(DuplicateAntennaNameWarning):
+    result = unique_antenna_names(names)
+  assert len(set(result.tolist())) == len(result)

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/xarray_ms/backend/msv2/entrypoint.py

@@ -25,7 +25,11 @@ from xarray_ms.backend.msv2.structure import (
   MSv2Structure,
   MSv2StructureFactory,
 )
-from xarray_ms.errors import FrameConversionWarning, InvalidPartitionKey
+from xarray_ms.errors import (
+  FrameConversionWarning,
+  IgnoredArgument,
+  InvalidPartitionKey,
+)
 from xarray_ms.msv4_types import CORRELATED_DATASET_TYPES
 from xarray_ms.multiton import Multiton
 from xarray_ms.utils import format_docstring
@@ -452,6 +456,13 @@ class MSv2EntryPoint(BackendEntrypoint):
     """Create a dictionary of :class:`~xarray.Dataset` presenting an MSv4 view
     over a partition of a MSv2 CASA Measurement Set"""
 
+    if kwargs:
+      warnings.warn(
+        f"xarray-ms does not support the following arguments and will ignore them: "
+        f"{sorted(kwargs)}",
+        IgnoredArgument,
+      )
+
     if isinstance(filename_or_obj, os.PathLike):
       ms = str(filename_or_obj)
     elif isinstance(filename_or_obj, str):
@@ -492,7 +503,6 @@ class MSv2EntryPoint(BackendEntrypoint):
         ninstances=store_args.ninstances,
         epoch=store_args.epoch,
         structure_factory=store_args.structure_factory,
-        **kwargs,
       )
 
       antenna_factory = AntennaFactory(

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/xarray_ms/backend/msv2/factories/antenna.py

@@ -4,6 +4,7 @@ from xarray import Dataset, Variable
 from xarray_ms.backend.msv2.factories.core import DatasetFactory
 from xarray_ms.backend.msv2.imputation import maybe_impute_observation_table
 from xarray_ms.backend.msv2.measures_encoders import MSv2CoderFactory
+from xarray_ms.backend.msv2.table_utils import unique_antenna_names
 from xarray_ms.errors import InvalidMeasurementSet
 
 RELOCATABLE_ARRAY = {"ALMA", "VLA", "NOEMA", "EVLA"}
@@ -53,7 +54,10 @@ class AntennaFactory(DatasetFactory):
       )
 
     ant_coder_factory = MSv2CoderFactory.from_arrow_table(filtered_ants)
-    antenna_names = filtered_ants["NAME"].to_numpy().astype(str)
+    # Deduplicate against the full ANTENNA table so suffix assignments are
+    # consistent with those produced in the correlated dataset factory.
+    all_ant_names = unique_antenna_names(ants["NAME"].to_numpy().astype(str))
+    antenna_names = all_ant_names[feed_ant_id[mask]]
     telescope_names = np.asarray([telescope_name] * len(antenna_names), dtype=str)
     position = pac.list_flatten(filtered_ants["POSITION"]).to_numpy().reshape(-1, 3)
     diameter = filtered_ants["DISH_DIAMETER"].to_numpy()

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/xarray_ms/backend/msv2/factories/correlated.py

@@ -26,6 +26,7 @@ from xarray_ms.backend.msv2.measures_encoders import (
   VisibilityCoder,
 )
 from xarray_ms.backend.msv2.structure import MSv2StructureFactory, PartitionKeyT
+from xarray_ms.backend.msv2.table_utils import unique_antenna_names
 from xarray_ms.casa_types import ColumnDesc, Polarisations
 from xarray_ms.errors import (
   ColumnShapeImputationWarning,
@@ -175,11 +176,16 @@ class CorrelatedFactory(DatasetFactory):
     from arcae.lib.arrow_tables import ms_descriptor
 
     # Ignore all standard msv2 columns, except
-    # for CORRECTED_DATA and CORRECTED_WEIGHT_SPECTRUM
+    # for CORRECTED_DATA, CORRECTED_WEIGHT_SPECTRUM, FLOAT_DATA and MODEL_DATA
     ignored_msv2_column_set = {
       c for c in ms_descriptor("MAIN", complete=True).keys() if not c.startswith("_")
     }
-    ignored_msv2_column_set -= {"CORRECTED_DATA", "CORRECTED_WEIGHT_SPECTRUM"}
+    ignored_msv2_column_set -= {
+      "CORRECTED_DATA",
+      "CORRECTED_WEIGHT_SPECTRUM",
+      "MODEL_DATA",
+      "FLOAT_DATA",
+    }
     remaining_columns = set(self._ms_factory.instance.columns())
     remaining_columns -= ignored_msv2_column_set
     remaining_columns -= processed_columns
@@ -266,7 +272,7 @@ class CorrelatedFactory(DatasetFactory):
     assert (partition.nbl,) == ant1.shape
 
     antenna = self._subtable_factories["ANTENNA"].instance
-    ant_names = antenna["NAME"].to_numpy().astype(str)
+    ant_names = unique_antenna_names(antenna["NAME"].to_numpy().astype(str))
     ant1_names = ant_names[ant1]
     ant2_names = ant_names[ant2]
 

xarray_ms-0.5.4/xarray_ms/backend/msv2/table_utils.py

@@ -0,0 +1,53 @@
+import json
+import warnings
+from typing import Any, Dict
+
+import numpy as np
+import pyarrow as pa
+
+from xarray_ms.errors import DuplicateAntennaNameWarning
+
+
+def unique_antenna_names(names: np.ndarray) -> np.ndarray:
+  """Return antenna names with duplicates made unique by appending -N suffixes.
+
+  All occurrences of a duplicated name are renamed: the first gets ``-1``,
+  the second ``-2``, and so on.  Names that are already unique are left
+  unchanged.  A :class:`~xarray_ms.errors.DuplicateAntennaNameWarning` is
+  emitted when any renaming is performed.
+  """
+  unique, counts = np.unique(names, return_counts=True)
+  if not (duplicates := set(unique[counts > 1].tolist())):
+    return names
+
+  warnings.warn(
+    f"Duplicate antenna names detected in the ANTENNA table: "
+    f"{sorted(duplicates)}. "
+    f"A numeric suffix will be appended to make names unique.",
+    DuplicateAntennaNameWarning,
+    stacklevel=2,
+  )
+  # Build as a Python list to avoid numpy fixed-width string truncation,
+  # then convert back to an array with a wide enough dtype.
+  result = names.tolist()
+  counters: Dict[str, int] = {}
+  for i, name in enumerate(result):
+    if name in duplicates:
+      counters[name] = counters.get(name, 0) + 1
+      result[i] = f"{name}-{counters[name]}"
+  return np.array(result, dtype=str)
+
+
+def extract_table_desc(table: pa.Table) -> Dict[str, Any]:
+  """Extract the CASA table descriptor stored in an Arrow table constructed by arcae"""
+  try:
+    arcae_metadata = table.schema.metadata[b"__arcae_metadata__"]
+  except KeyError:
+    raise KeyError("__arcae_metadata__ was not present in the table metadata")
+
+  try:
+    return json.loads(arcae_metadata)["__casa_descriptor__"]
+  except KeyError:
+    raise KeyError(
+      f"arcae metadata {arcae_metadata} does not contain a __casa_descriptor__"
+    )

{xarray_ms-0.5.1 → xarray_ms-0.5.4}/xarray_ms/errors.py

@@ -1,3 +1,7 @@
+class IgnoredArgument(UserWarning):
+  """Issued when keyword arguments are passed that this backend does not support."""
+
+
 class IrregularGridWarning(UserWarning):
   """Base Warning for irregular grids"""
 
@@ -30,6 +34,11 @@ class ImputedMetadataWarning(MissingMetadataWarning):
   if the original metadata is missing"""
 
 
+class DuplicateAntennaNameWarning(UserWarning):
+  """Warning raised when duplicate antenna names are found in the ANTENNA table
+  and are made unique by appending a numeric suffix"""
+
+
 class FrameConversionWarning(UserWarning):
   """Warning raised if there's no defined conversion from a CASA
   to astropy reference frame"""

xarray_ms-0.5.1/xarray_ms/backend/msv2/table_utils.py

@@ -1,19 +0,0 @@
-import json
-from typing import Any, Dict
-
-import pyarrow as pa
-
-
-def extract_table_desc(table: pa.Table) -> Dict[str, Any]:
-  """Extract the CASA table descriptor stored in an Arrow table constructed by arcae"""
-  try:
-    arcae_metadata = table.schema.metadata[b"__arcae_metadata__"]
-  except KeyError:
-    raise KeyError("__arcae_metadata__ was not present in the table metadata")
-
-  try:
-    return json.loads(arcae_metadata)["__casa_descriptor__"]
-  except KeyError:
-    raise KeyError(
-      f"arcae metadata {arcae_metadata} does not contain a __casa_descriptor__"
-    )