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

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

@@ -62,7 +62,7 @@ jobs:
       - name: Install xarray-ms
         run: |
           source .venv/bin/activate
-          pip install .[testing]
+          pip install --group test .
 
       - name: Test xarray-ms
         run: |

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/.readthedocs.yaml

@@ -12,11 +12,11 @@ build:
 
 python:
   install:
-    - method: pip
-      path: .
-      extra_requirements:
+    - method: uv
+      command: sync
+      groups:
         - doc
-        - testing
+        - test
 
 # Build documentation in the "docs/" directory with Sphinx
 sphinx:

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

@@ -1,31 +1,14 @@
 Metadata-Version: 2.4
 Name: xarray-ms
-Version: 0.5.4
+Version: 0.5.5
 Summary: xarray MSv4 views over MSv2 Measurement Sets
 Author-email: Simon Perkins <simon.perkins@gmail.com>
 License-File: LICENSE
 Requires-Python: >=3.11
-Requires-Dist: arcae<0.6.0,>=0.5.1
-Requires-Dist: cacheout>=0.16.0
+Requires-Dist: arcae<0.6.0,>=0.5.2
+Requires-Dist: rarg-python-patterns>=0.0.3
 Requires-Dist: typing-extensions>=4.12.2
 Requires-Dist: xarray>=2025.0
-Provides-Extra: dev
-Requires-Dist: pre-commit>=3.8.0; extra == 'dev'
-Requires-Dist: tbump>=6.11.0; extra == 'dev'
-Provides-Extra: doc
-Requires-Dist: ipython>=8.27.0; extra == 'doc'
-Requires-Dist: pydata-sphinx-theme>=0.15.4; extra == 'doc'
-Requires-Dist: pygments>=2.18.0; extra == 'doc'
-Requires-Dist: sphinx-copybutton>=0.5.2; extra == 'doc'
-Requires-Dist: sphinx>=8.0.2; extra == 'doc'
-Requires-Dist: sphinxcontrib-spelling; extra == 'doc'
-Provides-Extra: testing
-Requires-Dist: dask>=2024.5.0; extra == 'testing'
-Requires-Dist: distributed>=2024.5.0; extra == 'testing'
-Requires-Dist: platformdirs>=4.3.8; extra == 'testing'
-Requires-Dist: pytest>=8.0.0; extra == 'testing'
-Requires-Dist: xradio>=1.1.2; (python_version >= '3.11' and python_version < '3.14') and extra == 'testing'
-Requires-Dist: zarr<3.0.0,>=2.18.3; extra == 'testing'
 Description-Content-Type: text/x-rst
 
 xarray-ms

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

@@ -3,6 +3,15 @@
 Changelog
 =========
 
+0.5.5 (12-06-2026)
+------------------
+* Upgrade to arcae 0.5.2 (:pr:`161`)
+* Documentation fixes (:pr:`160`)
+* Replace ``xarray_ms.multiton.Multiton`` with ``rarg-python-patterns.multiton.Multiton`` (:pr:`159`)
+* Move development dependencies in dependency groups (:pr:`158`)
+* Remove ``*kwargs`` from ``MSv2EntryPoint`` methods (:pr:`156`)
+* Revert: Allow unsupported arguments in entrypoint methods (#154) (:pr:`155`)
+
 0.5.4 (20-05-2026)
 ------------------
 * Allow unsupported arguments in entrypoint methods (:pr:`154`)
@@ -41,7 +50,7 @@ Changelog
 * Synchronise with v4.0.0 schema version (:pr:`139`)
 * Remove ``correlated_xds.scan_number`` coordinate (:pr:`139`)
 * Remove ``correlated_xds.sub_scan_number`` coordinate (:pr:`139`)
-* Add ``corelated_xds.scan_name`` coordinate (:pr:`139`)
+* Add ``correlated_xds.scan_name`` coordinate (:pr:`139`)
 * Add ``correlated_xds.frequency.spectral_window_intents`` coordinate attribute (:pr:`139`)
 * Remove ``correlated_xds.observation_info["intents"]`` (:pr:`139`)
 * Rename ``correlated_xds.observation_info["project"]`` to ``"project_UID"`` (:pr:`139`)

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/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.4"
+release = "0.5.5"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/doc/source/install.rst

@@ -16,31 +16,27 @@ they must be installed separately.
 Development
 ===========
 
-Create a virtual environment and install with the dev, doc and testing
-dependencies:
+Install with the dev, doc and testing dependencies using uv_:
 
 .. code-block:: bash
 
-
-  $ virtualenv -p python3.12 /tmp/xms
-  $ source xms/bin/activate
-  (xms) $ pip install -e .[dev,doc,testing]
+  $ uv sync --group dev --group test --group doc
 
 The pre-commit hooks can be manually executed as follows:
 
 .. code-block:: bash
 
-  (xms) $ pre-commit run -a
+  $ uv run --dev pre-commit run -a
 
 Test Suite
 ----------
 
-After creating the virtual environment above, run the following command
+After installing the dependencies above, run the following command
 within the xarray-ms source code directory to execute the test suite:
 
 .. code-block:: bash
 
-  (xms) $ py.test -s -vvv tests/
+  $ uv run --group test py.test tests/
 
 
 Documentation
@@ -51,8 +47,8 @@ build the Sphinx documentation
 
 .. code-block:: bash
 
-  (xms) $ cd doc
-  (xms) $ make html
+  $ cd doc
+  $ make html
 
 Release Process
 ---------------

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/doc/source/links.rst

@@ -17,3 +17,4 @@
 .. _xarray_indexing_and_selecting: https://docs.xarray.dev/en/latest/user-guide/indexing.html
 .. _xarray_chunked_arrays: https://docs.xarray.dev/en/latest/internals/chunked-arrays.html
 .. _zarr: https://zarr.dev/
+.. _uv: https://docs.astral.sh/uv/

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/doc/source/partitioning.rst

@@ -43,7 +43,7 @@ is that it can represent overlapped or disjoint measurements in time and frequen
 for one or more baselines.
 However, most observational data is well-behaved:
 Measurements are commonly ordered by ``TIME, ANTENNA1, ANTENNA2``
-and ``CHAN_FREQ`` commonly increases monotically with
+and ``CHAN_FREQ`` commonly increases monotonically with
 equidistant values (i.e. ``CHAN_WIDTH`` values are uniform) but this cannot
 always be assumed.
 Any regularity in an MSv2 MS is achieved through convention rather
@@ -86,7 +86,7 @@ Partitioning in time
 Compared to frequency, achieving regularity in time requires more thought
 as it depends on identifying partitions of MSv2 where data:
 
-1. contains monotically increasing ``TIME`` (after ordering).
+1. contains monotonically increasing ``TIME`` (after ordering).
 2. is dumped with a uniform ``INTERVAL``.
 3. ideally contains no gaps: i.e. ``(TIME - INTERVAL)[1:] == (TIME + INTERVAL)[:-1]``.
 

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/doc/source/roadmap.rst

@@ -18,7 +18,7 @@ In particular, it loads the MSv2 dataset present in the
 `Measurement Set v4 test suite <msv4-test-suite_>`_ except for:
 
 - ALMA Measurement Sets which sometimes do not correctly link
-  the ANTENNNA and MAIN table via the FEED table.
+  the ANTENNA and MAIN table via the FEED table.
   This will need to be addressed heuristically.
 - Single-dish Measurement Sets.
   This is not difficult as it involves loading in

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/doc/source/tutorial.rst

@@ -55,7 +55,7 @@ with a lazy view over the data.
 xarray has extensive functionality for
 `indexing and selecting data <xarray_indexing_and_selecting_>`_.
 
-For example, one could select select some specific dimensions out:
+For example, one could select some specific dimensions out:
 
 .. ipython:: python
 

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

@@ -1,19 +1,19 @@
 [project]
 name = "xarray-ms"
-version = "0.5.4"
+version = "0.5.5"
 description = "xarray MSv4 views over MSv2 Measurement Sets"
 authors = [{name = "Simon Perkins", email = "simon.perkins@gmail.com"}]
 readme = "README.rst"
 requires-python = ">=3.11"
 dependencies = [
     "xarray>=2025.0",
-    "cacheout>=0.16.0",
-    "arcae>=0.5.1, < 0.6.0",
+    "arcae>=0.5.2, < 0.6.0",
     "typing-extensions>=4.12.2",
+    "rarg-python-patterns>=0.0.3",
 ]
 
-[project.optional-dependencies]
-testing = [
+[dependency-groups]
+test = [
     "pytest>=8.0.0",
     "dask>=2024.5.0",
     "distributed>=2024.5.0",
@@ -55,7 +55,7 @@ extend-select = ["I"]
 # github_url = "https://github.com/<user or organization>/<project>/"
 
 [tool.tbump.version]
-current = "0.5.4"
+current = "0.5.5"
 
 # Example of a semver regexp.
 # Make sure this matches current_version before

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/tests/conftest.py

@@ -1,9 +1,8 @@
 import numpy as np
 import pytest
 from arcae.lib.arrow_tables import Table, ms_descriptor
+from rarg_python_patterns.multiton import Multiton
 
-from xarray_ms.backend.msv2.structure import MSv2StructureFactory
-from xarray_ms.multiton import Multiton
 from xarray_ms.testing.simulator import DEFAULT_SIM_PARAMS, MSStructureSimulator
 
 MSV4_TEST_CORPUS = "msv4_test_corpus"
@@ -39,7 +38,7 @@ def pytest_collection_modifyitems(config, items):
 def clear_caches():
   yield
   Multiton._INSTANCE_CACHE.clear()
-  MSv2StructureFactory._STRUCTURE_CACHE.clear()
+  Multiton._EXPIRY_HEAP.clear()
 
 
 @pytest.fixture(scope="session", params=[DEFAULT_SIM_PARAMS])

xarray_ms-0.5.5/tests/test_accessors.py

@@ -0,0 +1,24 @@
+import pytest
+import xarray
+
+
+@pytest.mark.skip
+@pytest.mark.filterwarnings("ignore:.*?matched multiple partitions")
+@pytest.mark.parametrize(
+  "simmed_ms",
+  [
+    {
+      "name": "backend.ms",
+      "data_description": [(8, ["XX", "XY", "YX", "YY"]), (4, ["RR", "LL"])],
+    }
+  ],
+  indirect=True,
+)
+def test_accessors(simmed_ms):
+  dt = xarray.open_datatree(simmed_ms)
+  dt["/backend/partition_000"].attrs["links"] = {
+    "antenna": "/backend/partition_000/ANTENNA",
+    "weather": "/backend/partition_000/weather_xds",
+  }
+  # print(dt)
+  print(dt["/backend/partition_000"].links.antenna)

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

@@ -7,7 +7,6 @@ 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
 
 
@@ -238,14 +237,3 @@ 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.4 → xarray_ms-0.5.5}/tests/test_structure.py

@@ -7,13 +7,15 @@ import pytest
 import xarray
 from arcae.lib.arrow_tables import Table
 from numpy.testing import assert_array_equal, assert_equal
+from rarg_python_patterns.multiton import Multiton
 
 from xarray_ms.backend.msv2.structure import (
-  MSv2StructureFactory,
+  MainTableFactory,
+  MSv2Structure,
+  SubtableFactory,
   TablePartitioner,
   baseline_id,
 )
-from xarray_ms.multiton import Multiton
 
 
 @pytest.mark.parametrize("na", [1, 2, 3, 4, 7])
@@ -34,20 +36,20 @@ def test_structure_factory(simmed_ms, epoch):
     "OBSERVATION_ID",
     "OBS_MODE",
   ]
-  table_factory = Multiton(Table.from_filename, simmed_ms)
+  table_factory: MainTableFactory = Multiton(Table.from_filename, simmed_ms)
   from xarray_ms.backend.msv2.entrypoint_utils import subtable_factory
 
-  subtables = {
+  subtables: dict[str, SubtableFactory] = {
     st: Multiton(subtable_factory, f"{simmed_ms}::{st}")
     for st in ("DATA_DESCRIPTION", "FEED", "FIELD", "STATE")
   }
-  structure_factory = MSv2StructureFactory(
-    table_factory, subtables, partition_schema, epoch, True
+  structure_factory = Multiton(
+    MSv2Structure, table_factory, subtables, partition_schema, epoch, True
   )
   assert pickle.loads(pickle.dumps(structure_factory)) == structure_factory
 
-  structure_factory2 = MSv2StructureFactory(
-    table_factory, subtables, partition_schema, epoch, True
+  structure_factory2 = Multiton(
+    MSv2Structure, table_factory, subtables, partition_schema, epoch, True
   )
   assert structure_factory.instance is structure_factory2.instance
 
@@ -114,34 +116,40 @@ def test_table_partitioner():
 
 def test_epoch(simmed_ms):
   partition_schema = ["FIELD_ID", "DATA_DESC_ID", "OBSERVATION_ID"]
-  table_factory = Multiton(Table.from_filename, simmed_ms)
+  table_factory: MainTableFactory = Multiton(Table.from_filename, simmed_ms)
   from xarray_ms.backend.msv2.entrypoint_utils import subtable_factory
 
-  subtables = {
+  subtables: dict[str, SubtableFactory] = {
     st: Multiton(subtable_factory, f"{simmed_ms}::{st}")
     for st in ("DATA_DESCRIPTION", "FEED", "FIELD", "STATE")
   }
 
-  structure_factory = MSv2StructureFactory(
-    table_factory, subtables, partition_schema, "abc", True
+  structure_factory = Multiton(
+    MSv2Structure, table_factory, subtables, partition_schema, "abc", True
   )
-  structure_factory2 = MSv2StructureFactory(
-    table_factory, subtables, partition_schema, "abc", True
+  structure_factory2 = Multiton(
+    MSv2Structure, table_factory, subtables, partition_schema, "abc", True
   )
 
   assert structure_factory.instance is structure_factory2.instance
 
-  structure_factory3 = MSv2StructureFactory(
-    table_factory, subtables, partition_schema, "def", True
+  structure_factory3 = Multiton(
+    MSv2Structure, table_factory, subtables, partition_schema, "def", True
   )
 
   assert structure_factory.instance is not structure_factory3.instance
 
 
 def test_msv2_structure_release(simmed_ms):
-  assert len(MSv2StructureFactory._STRUCTURE_CACHE) == 0
+  def ncached_structures():
+    return sum(
+      isinstance(obj, MSv2Structure)
+      for obj, _, _, _ in Multiton._INSTANCE_CACHE.values()
+    )
+
+  assert ncached_structures() == 0
 
   with xarray.open_datatree(simmed_ms):
-    assert len(MSv2StructureFactory._STRUCTURE_CACHE) > 0
+    assert ncached_structures() > 0
 
-  assert len(MSv2StructureFactory._STRUCTURE_CACHE) == 0
+  assert ncached_structures() == 0

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/xarray_ms/backend/msv2/array.py

@@ -15,8 +15,11 @@ from xarray.core.indexing import (
 if TYPE_CHECKING:
   import numpy.typing as npt
 
-  from xarray_ms.backend.msv2.structure import MSv2StructureFactory, PartitionKeyT
-  from xarray_ms.multiton import Multiton
+  from xarray_ms.backend.msv2.structure import (
+    MainTableFactory,
+    MSv2StructureFactory,
+    PartitionKeyT,
+  )
 
   TransformerT = Callable[[npt.NDArray], npt.NDArray]
 
@@ -73,7 +76,7 @@ class MainMSv2Array(MSv2Array):
     "_transform",
   )
 
-  _table_factory: Multiton
+  _table_factory: MainTableFactory
   _structure_factory: MSv2StructureFactory
   _partition: PartitionKeyT
   _column: str
@@ -82,7 +85,7 @@ class MainMSv2Array(MSv2Array):
 
   def __init__(
     self,
-    table_factory: Multiton,
+    table_factory: MainTableFactory,
     structure_factory: MSv2StructureFactory,
     partition: PartitionKeyT,
     column: str,

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

@@ -25,13 +25,8 @@ from xarray_ms.backend.msv2.structure import (
   MSv2Structure,
   MSv2StructureFactory,
 )
-from xarray_ms.errors import (
-  FrameConversionWarning,
-  IgnoredArgument,
-  InvalidPartitionKey,
-)
+from xarray_ms.errors import FrameConversionWarning, InvalidPartitionKey
 from xarray_ms.msv4_types import CORRELATED_DATASET_TYPES
-from xarray_ms.multiton import Multiton
 from xarray_ms.utils import format_docstring
 
 if TYPE_CHECKING:
@@ -39,7 +34,12 @@ if TYPE_CHECKING:
 
   from xarray.backends.common import AbstractDataStore
 
-  from xarray_ms.backend.msv2.structure import DEFAULT_PARTITION_COLUMNS, PartitionKeyT
+  from xarray_ms.backend.msv2.structure import (
+    DEFAULT_PARTITION_COLUMNS,
+    MainTableFactory,
+    PartitionKeyT,
+    SubtableFactory,
+  )
 
 
 def promote_chunks(
@@ -90,8 +90,8 @@ class MSv2Store(AbstractWritableDataStore):
     "_epoch",
   )
 
-  _table_factory: Multiton
-  _subtable_factories: Dict[str, Multiton]
+  _table_factory: MainTableFactory
+  _subtable_factories: Dict[str, SubtableFactory]
   _structure_factory: MSv2StructureFactory
   _partition_schema: List[str]
   _partition_key: PartitionKeyT
@@ -102,8 +102,8 @@ class MSv2Store(AbstractWritableDataStore):
 
   def __init__(
     self,
-    table_factory: Multiton,
-    subtable_factories: Dict[str, Multiton],
+    table_factory: MainTableFactory,
+    subtable_factories: Dict[str, SubtableFactory],
     structure_factory: MSv2StructureFactory,
     partition_schema: List[str],
     partition_key: PartitionKeyT,
@@ -314,7 +314,6 @@ class MSv2EntryPoint(BackendEntrypoint):
     auto_corrs: bool = False,
     ninstances: int = 8,
     epoch: str | None = None,
-    **kwargs,
   ) -> DataTree:
     """Create a :class:`~xarray.core.datatree.DataTree` presenting an MSv4 view
     over multiple partitions of a MSv2 CASA Measurement Set.
@@ -370,7 +369,6 @@ class MSv2EntryPoint(BackendEntrypoint):
       auto_corrs=auto_corrs,
       ninstances=ninstances,
       epoch=epoch,
-      **kwargs,
     )
 
     dt = DataTree.from_dict(groups_dict)
@@ -451,18 +449,10 @@ class MSv2EntryPoint(BackendEntrypoint):
     ninstances: int = 8,
     epoch: str | None = None,
     structure_factory: MSv2StructureFactory | None = None,
-    **kwargs,
   ) -> Dict[str, Dataset]:
     """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):

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/xarray_ms/backend/msv2/entrypoint_utils.py

@@ -4,12 +4,15 @@ from uuid import uuid4
 
 import pyarrow as pa
 from arcae.lib.arrow_tables import Table
+from rarg_python_patterns.multiton import Multiton
 
 from xarray_ms.backend.msv2.structure import (
   DEFAULT_PARTITION_COLUMNS,
+  MainTableFactory,
+  MSv2Structure,
   MSv2StructureFactory,
+  SubtableFactory,
 )
-from xarray_ms.multiton import Multiton
 
 # These tables should always be present on an MS
 DEFAULT_SUBTABLES = [
@@ -59,8 +62,8 @@ class CommonStoreArgs:
   epoch: str
   partition_schema: List[str]
   preferred_chunks: Dict[str, int]
-  ms_factory: Multiton
-  subtable_factories: Dict[str, Multiton]
+  ms_factory: MainTableFactory
+  subtable_factories: Dict[str, SubtableFactory]
   structure_factory: MSv2StructureFactory
 
   __slots__ = (
@@ -83,8 +86,8 @@ class CommonStoreArgs:
     epoch: str | None = None,
     partition_schema: List[str] | None = None,
     preferred_chunks: Dict[str, int] | None = None,
-    ms_factory: Multiton | None = None,
-    subtable_factories: Dict[str, Multiton] | None = None,
+    ms_factory: MainTableFactory | None = None,
+    subtable_factories: Dict[str, SubtableFactory] | None = None,
     structure_factory: MSv2StructureFactory | None = None,
   ):
     if not os.path.exists(ms):
@@ -107,7 +110,8 @@ class CommonStoreArgs:
       subtable: Multiton(subtable_factory, f"{ms}::{subtable}")
       for subtable in (DEFAULT_SUBTABLES + EXTRA_SUBTABLES)
     }
-    self.structure_factory = structure_factory or MSv2StructureFactory(
+    self.structure_factory = structure_factory or Multiton(
+      MSv2Structure,
       self.ms_factory,
       self.subtable_factories,
       self.partition_schema,

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/xarray_ms/backend/msv2/factories/core.py

@@ -1,7 +1,10 @@
 from typing import Dict
 
-from xarray_ms.backend.msv2.structure import MSv2StructureFactory, PartitionKeyT
-from xarray_ms.multiton import Multiton
+from xarray_ms.backend.msv2.structure import (
+  MSv2StructureFactory,
+  PartitionKeyT,
+  SubtableFactory,
+)
 
 
 class DatasetFactory:
@@ -10,13 +13,13 @@ class DatasetFactory:
 
   _partition_key: PartitionKeyT
   _structure_factory: MSv2StructureFactory
-  _subtable_factories: Dict[str, Multiton]
+  _subtable_factories: Dict[str, SubtableFactory]
 
   def __init__(
     self,
     partition_key: PartitionKeyT,
     structure_factory: MSv2StructureFactory,
-    subtable_factories: Dict[str, Multiton],
+    subtable_factories: Dict[str, SubtableFactory],
   ):
     self._partition_key = partition_key
     self._structure_factory = structure_factory

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

@@ -25,7 +25,12 @@ from xarray_ms.backend.msv2.measures_encoders import (
   MSv2CoderFactory,
   VisibilityCoder,
 )
-from xarray_ms.backend.msv2.structure import MSv2StructureFactory, PartitionKeyT
+from xarray_ms.backend.msv2.structure import (
+  MainTableFactory,
+  MSv2StructureFactory,
+  PartitionKeyT,
+  SubtableFactory,
+)
 from xarray_ms.backend.msv2.table_utils import unique_antenna_names
 from xarray_ms.casa_types import ColumnDesc, Polarisations
 from xarray_ms.errors import (
@@ -35,7 +40,6 @@ from xarray_ms.errors import (
   IrregularChannelGridWarning,
   IrregularTimeGridWarning,
 )
-from xarray_ms.multiton import Multiton
 
 
 @dataclasses.dataclass
@@ -82,11 +86,11 @@ class CorrelatedFactory(DatasetFactory):
   for a partition of the Measurement Set"""
 
   _preferred_chunks: Dict[str, int]
-  _ms_factory: Multiton
-  _antenna_factory: Multiton
-  _spw_factory: Multiton
-  _pol_factory: Multiton
-  _obs_factory: Multiton
+  _ms_factory: MainTableFactory
+  _antenna_factory: SubtableFactory
+  _spw_factory: SubtableFactory
+  _pol_factory: SubtableFactory
+  _obs_factory: SubtableFactory
   _main_table_desc: Dict[str, Collection[str]]
   _coder_factory: MSv2CoderFactory
 
@@ -94,8 +98,8 @@ class CorrelatedFactory(DatasetFactory):
     self,
     partition_key: PartitionKeyT,
     preferred_chunks: Dict[str, int],
-    ms_factory: Multiton,
-    subtable_factories: Dict[str, Multiton],
+    ms_factory: MainTableFactory,
+    subtable_factories: Dict[str, SubtableFactory],
     structure_factory: MSv2StructureFactory,
   ):
     super().__init__(partition_key, structure_factory, subtable_factories)

{xarray_ms-0.5.4 → xarray_ms-0.5.5}/xarray_ms/backend/msv2/structure.py

@@ -10,7 +10,6 @@ from functools import partial
 from numbers import Integral
 from typing import (
   Any,
-  ClassVar,
   Dict,
   Iterator,
   List,
@@ -19,13 +18,14 @@ from typing import (
   Sequence,
   Set,
   Tuple,
+  TypeAlias,
 )
 
 import numpy as np
 import numpy.typing as npt
 import pyarrow as pa
 from arcae.lib.arrow_tables import Table
-from cacheout import Cache
+from rarg_python_patterns.multiton import Multiton
 
 from xarray_ms.backend.msv2.imputation import (
   maybe_impute_field_table,
@@ -37,10 +37,18 @@ from xarray_ms.errors import (
   InvalidPartitionKey,
   PartitioningError,
 )
-from xarray_ms.multiton import Multiton
 
 logger = logging.getLogger(__name__)
 
+MainTableFactory: TypeAlias = Multiton[Table]
+"""Multiton producing an arcae main-table :class:`~arcae.lib.arrow_tables.Table`."""
+
+SubtableFactory: TypeAlias = Multiton[pa.Table]
+"""Multiton producing a pyarrow :class:`~pyarrow.Table` subtable."""
+
+MSv2StructureFactory: TypeAlias = Multiton["MSv2Structure"]
+"""Multiton producing an :class:`MSv2Structure`."""
+
 
 def nr_of_baselines(na: int, auto_corrs: bool = True) -> int:
   """Returns the number of baselines, given the number of antenna
@@ -227,96 +235,14 @@ class PartitionData:
     return aids[a1], aids[a2]
 
 
-def on_get_keep_alive(key, value, exists):
-  """Reinsert to refresh the TTL for the entry on get operations"""
-  if exists:
-    MSv2StructureFactory._STRUCTURE_CACHE._set(key, value)
-
-
-class MSv2StructureFactory:
-  """Hashable, callable and picklable factory class
-  for creating and caching an MSv2Structure"""
-
-  _ms_factory: Multiton
-  _subtable_factories: Dict[str, Multiton]
-  _partition_schema: List[str]
-  _epoch: str
-  _auto_corrs: bool
-  _STRUCTURE_CACHE: ClassVar[Cache] = Cache(
-    maxsize=100, ttl=5 * 60, on_get=on_get_keep_alive
-  )
-
-  def __init__(
-    self,
-    ms: Multiton,
-    subtables: Dict[str, Multiton],
-    partition_schema: List[str],
-    epoch: str,
-    auto_corrs: bool,
-  ):
-    self._ms_factory = ms
-    self._subtable_factories = subtables
-    self._partition_schema = partition_schema
-    self._epoch = epoch
-    self._auto_corrs = auto_corrs
-
-  def __eq__(self, other: Any) -> bool:
-    if not isinstance(other, MSv2StructureFactory):
-      return NotImplemented
-
-    return (
-      self._ms_factory == other._ms_factory
-      and self._subtable_factories == other._subtable_factories
-      and self._partition_schema == other._partition_schema
-      and self._epoch == other._epoch
-      and self._auto_corrs == other._auto_corrs
-    )
-
-  def __hash__(self):
-    return hash(
-      (
-        self._ms_factory,
-        frozenset(self._subtable_factories.items()),
-        tuple(self._partition_schema),
-        self._epoch,
-        self._auto_corrs,
-      )
-    )
-
-  def __reduce__(self):
-    return (
-      MSv2StructureFactory,
-      (
-        self._ms_factory,
-        self._subtable_factories,
-        self._partition_schema,
-        self._epoch,
-        self._auto_corrs,
-      ),
-    )
-
-  @staticmethod
-  def _create_instance(self):
-    return MSv2Structure(
-      self._ms_factory,
-      self._subtable_factories,
-      self._partition_schema,
-      self._auto_corrs,
-    )
-
-  @property
-  def instance(self) -> MSv2Structure:
-    return self._STRUCTURE_CACHE.get(self, self._create_instance)
-
-  def release(self) -> bool:
-    return self._STRUCTURE_CACHE.delete(self) > 0
-
-
 class MSv2Structure(Mapping):
   """Holds structural information about an MSv2 dataset"""
 
-  _ms_factory: Multiton
-  _subtable_factories: Dict[str, Multiton]
+  _ms_factory: MainTableFactory
+  _subtable_factories: Dict[str, SubtableFactory]
+  # Not used internally, but distinguishes Multiton keys so that
+  # different epochs force regeneration of the same structure
+  _epoch: str
   _partition_columns: List[str]
   _subtable_partition_columns: List[str]
   _partitions: Mapping[PartitionKeyT, PartitionData]
@@ -606,9 +532,10 @@ class MSv2Structure(Mapping):
 
   def __init__(
     self,
-    ms: Multiton,
-    subtable_factories: Dict[str, Multiton],
+    ms: MainTableFactory,
+    subtable_factories: Dict[str, SubtableFactory],
     partition_schema: List[str],
+    epoch: str,
     auto_corrs: bool,
   ):
     import time as modtime
@@ -621,6 +548,7 @@ class MSv2Structure(Mapping):
 
     self._ms_factory = ms
     self._subtable_factories = subtable_factories
+    self._epoch = epoch
     self._partition_columns = partition_columns
     self._subtable_partition_columns = subtable_columns
 

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

@@ -1,7 +1,3 @@
-class IgnoredArgument(UserWarning):
-  """Issued when keyword arguments are passed that this backend does not support."""
-
-
 class IrregularGridWarning(UserWarning):
   """Base Warning for irregular grids"""
 

xarray_ms-0.5.4/tests/test_multiton.py

@@ -1,70 +0,0 @@
-import pickle
-
-import xarray
-from arcae.lib.arrow_tables import Table
-
-from xarray_ms.multiton import Multiton
-
-
-def test_multiton_duplicate_args(simmed_ms):
-  """Tests that when opened with duplicate arguments,
-  the same Multiton is returned"""
-
-  multiton = Multiton(Table.from_filename, simmed_ms, readonly=False)
-  data = multiton.instance.getcol("DATA")
-  assert data.shape == (30, 8, 4)
-  assert set(multiton._INSTANCE_CACHE.keys()) == {multiton}
-
-  multiton2 = Multiton(Table.from_filename, simmed_ms, readonly=False)
-  assert multiton2.instance is multiton.instance
-  assert set(multiton._INSTANCE_CACHE.keys()) == {multiton}
-
-  multiton3 = Multiton(Table.from_filename, simmed_ms)
-  assert multiton3.instance is not multiton.instance
-  assert multiton3.instance is not multiton2.instance
-  assert set(multiton._INSTANCE_CACHE.keys()) == {multiton, multiton3}
-
-  # Check the positional args passed as kwargs are normalised
-  # as positional args
-  multiton4 = Multiton(Table.from_filename, filename=simmed_ms, readonly=False)
-  assert multiton4.instance is multiton.instance
-  assert multiton4.instance is multiton2.instance
-  assert multiton4.instance is not multiton3.instance
-  assert set(multiton._INSTANCE_CACHE.keys()) == {multiton, multiton3}
-
-
-def test_multiton_release():
-  data = {"closed": False}
-
-  class A:
-    def close(self):
-      data["closed"] = True
-
-  multiton = Multiton(A)
-  multiton.instance
-  assert set(multiton._INSTANCE_CACHE.keys()) == {multiton}
-  multiton.release()
-  assert set(multiton._INSTANCE_CACHE.keys()) == set()
-  assert data["closed"] is True
-
-
-def test_multiton_datatree_release(simmed_ms):
-  assert len(Multiton._INSTANCE_CACHE) == 0
-
-  with xarray.open_datatree(simmed_ms):
-    assert len(Multiton._INSTANCE_CACHE) > 0
-
-  assert len(Multiton._INSTANCE_CACHE) == 0
-
-
-def test_multiton_pickling(simmed_ms):
-  """Test that a pickle roundtrip of the Multiton results in the same object"""
-
-  multiton = Multiton(Table.from_filename, simmed_ms)
-  data = multiton.instance.getcol("DATA")
-  assert data.shape == (30, 8, 4)
-  assert set(multiton._INSTANCE_CACHE.keys()) == {multiton}
-
-  multiton2 = pickle.loads(pickle.dumps(multiton))
-  assert multiton.instance is multiton2.instance
-  assert set(multiton._INSTANCE_CACHE.keys()) == {multiton}

xarray_ms-0.5.4/xarray_ms/multiton.py

@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Callable, ClassVar, Mapping, Tuple
-
-from cacheout import Cache
-
-from xarray_ms.utils import FrozenKey, normalise_args
-
-FactoryFunctionT = Callable[..., Any]
-
-
-def on_get_keep_alive(key, value, exists):
-  """Re-insert on get to update the TTL"""
-  if exists:
-    # Re-insert to update the TTL
-    Multiton._INSTANCE_CACHE.set(key, value)
-
-
-def on_instance_delete(key, value, cause):
-  """Invoke any instance close methods on deletion"""
-  if hasattr(value, "close") and callable(value.close):
-    value.close()
-
-
-class Multiton:
-  """Hashable and pickleable factory class
-  for creating and caching an object instance"""
-
-  _INSTANCE_CACHE: ClassVar[Cache] = Cache(
-    maxsize=100, ttl=5 * 60, on_get=on_get_keep_alive, on_delete=on_instance_delete
-  )
-  _factory: FactoryFunctionT
-  _args: Tuple[Any, ...]
-  _kw: Mapping[str, Any]
-  _key: FrozenKey
-
-  def __init__(self, factory: FactoryFunctionT, *args: Any, **kw: Any):
-    self._factory = factory
-    self._args, self._kw = normalise_args(factory, args, kw)
-    self._key = FrozenKey(factory, *self._args, **self._kw)
-
-  @staticmethod
-  def from_reduce_args(
-    factory: FactoryFunctionT, args: Tuple[Any, ...], kw: Mapping[str, Any]
-  ) -> Multiton:
-    return Multiton(factory, *args, **kw)
-
-  def __reduce__(
-    self,
-  ) -> Tuple[Callable, Tuple[Callable, Tuple[Any, ...], Mapping[str, Any]]]:
-    return (self.from_reduce_args, (self._factory, self._args, self._kw))
-
-  def __hash__(self) -> int:
-    return hash(self._key)
-
-  def __eq__(self, other: Any) -> bool:
-    if not isinstance(other, Multiton):
-      return NotImplemented
-    return self._key == other._key
-
-  @staticmethod
-  def _create_instance(self) -> Any:
-    return self._factory(*self._args, **self._kw)
-
-  @property
-  def instance(self) -> Any:
-    """Create the object instance represented by the Multiton,
-    or retrieved the cache instance"""
-    return self._INSTANCE_CACHE.get(self, self._create_instance)
-
-  def release(self) -> bool:
-    """Evict any cached instance associated with this Multiton"""
-    return self._INSTANCE_CACHE.delete(self) > 0