xarray-ms 0.4.0a5__tar.gz → 0.4.0a6__tar.gz

{xarray_ms-0.4.0a5 → xarray_ms-0.4.0a6}/.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.4.0a5 → xarray_ms-0.4.0a6}/.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.4.0a5 → xarray_ms-0.4.0a6}/PKG-INFO

@@ -1,31 +1,14 @@
 Metadata-Version: 2.4
 Name: xarray-ms
-Version: 0.4.0a5
+Version: 0.4.0a6
 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.5.0,>=0.4.0a4
-Requires-Dist: cacheout>=0.16.0
+Requires-Dist: arcae<0.5.0,>=0.4.0a5
+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.4.0a5 → xarray_ms-0.4.0a6}/doc/source/changelog.rst

@@ -3,6 +3,23 @@
 Changelog
 =========
 
+X.Y.Z (DD-MM-YYYY)
+------------------
+* Introduce ``pytest != 9.1.0`` version restriction (:pr:`162`)
+
+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`)
+
 0.5.3 (11-05-2026)
 ------------------
 * Expand standard msv2 columns supported during reads (:pr:`153`)
@@ -37,7 +54,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.4.0a5 → xarray_ms-0.4.0a6}/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.4.0-alpha.5"
+release = "0.4.0-alpha.6"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

{xarray_ms-0.4.0a5 → xarray_ms-0.4.0a6}/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.4.0a5 → xarray_ms-0.4.0a6}/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.4.0a5 → xarray_ms-0.4.0a6}/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.4.0a5 → xarray_ms-0.4.0a6}/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.4.0a5 → xarray_ms-0.4.0a6}/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.4.0a5 → xarray_ms-0.4.0a6}/pyproject.toml

@@ -1,20 +1,20 @@
 [project]
 name = "xarray-ms"
-version = "0.4.0-alpha.5"
+version = "0.4.0-alpha.6"
 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.4.0a4, < 0.5.0",
+    "arcae>=0.4.0a5, < 0.5.0",
     "typing-extensions>=4.12.2",
+    "rarg-python-patterns>=0.0.3",
 ]
 
-[project.optional-dependencies]
-testing = [
-    "pytest>=8.0.0",
+[dependency-groups]
+test = [
+    "pytest>=8.0.0,!=9.1.0",
     "dask>=2024.5.0",
     "distributed>=2024.5.0",
     "zarr>=2.18.3, <3.0.0",
@@ -55,7 +55,7 @@ extend-select = ["I"]
 # github_url = "https://github.com/<user or organization>/<project>/"
 
 [tool.tbump.version]
-current = "0.4.0-alpha.5"
+current = "0.4.0-alpha.6"
 
 # https://semver.org/#spec-item-9
 regex = '''

{xarray_ms-0.4.0a5 → xarray_ms-0.4.0a6}/tests/conftest.py

@@ -3,9 +3,8 @@ import gc
 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"
@@ -40,10 +39,8 @@ def pytest_collection_modifyitems(config, items):
 @pytest.fixture(autouse=True)
 def clear_caches():
   yield
-
-  # Structure Factories have references to Multitons
-  MSv2StructureFactory._STRUCTURE_CACHE.clear()
   Multiton._INSTANCE_CACHE.clear()
+  Multiton._EXPIRY_HEAP.clear()
   gc.collect()
 
 

xarray_ms-0.4.0a6/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.4.0a5 → xarray_ms-0.4.0a6}/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.4.0a5 → xarray_ms-0.4.0a6}/xarray_ms/backend/msv2/array.py

@@ -21,8 +21,11 @@ from xarray_ms.msv4_types import MAIN_PREFIX_DIMS
 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]
 
@@ -113,7 +116,7 @@ class MainMSv2Array(MSv2Array):
     "_transform",
   )
 
-  _table_factory: Multiton
+  _table_factory: MainTableFactory
   _structure_factory: MSv2StructureFactory
   _partition: PartitionKeyT
   _column: str
@@ -122,7 +125,7 @@ class MainMSv2Array(MSv2Array):
 
   def __init__(
     self,
-    table_factory: Multiton,
+    table_factory: MainTableFactory,
     structure_factory: MSv2StructureFactory,
     partition: PartitionKeyT,
     column: str,

{xarray_ms-0.4.0a5 → xarray_ms-0.4.0a6}/xarray_ms/backend/msv2/entrypoint.py

@@ -28,15 +28,19 @@ from xarray_ms.backend.msv2.structure import (
 )
 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
+from xarray_ms.utils import format_docstring, function_arguments
 
 if TYPE_CHECKING:
   from io import BufferedIOBase
 
   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,
+  )
 
 
 WriteRegionT = Mapping[str, slice | Literal["auto"]] | Literal["auto"]
@@ -91,8 +95,8 @@ class MSv2Store(AbstractWritableDataStore):
     "_write_region",
   )
 
-  _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
@@ -104,8 +108,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,
@@ -232,7 +236,8 @@ class MSv2Store(AbstractWritableDataStore):
     of the Measurement Set.
 
     Overrides AbstractDataStore.get_encoding"""
-    table_args = self._table_factory.arguments()
+    multiton = self._table_factory
+    table_args = function_arguments(multiton._factory, multiton._args, multiton._kw)
 
     return {
       "common_store_args": {
@@ -315,7 +320,7 @@ class MSv2Store(AbstractWritableDataStore):
     self._write_region = expanded_region
 
   @property
-  def table_factory(self) -> Multiton:
+  def table_factory(self) -> MainTableFactory:
     """Return the table factory associated with this store"""
     return self._table_factory
 
@@ -418,7 +423,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.
@@ -474,7 +478,6 @@ class MSv2EntryPoint(BackendEntrypoint):
       auto_corrs=auto_corrs,
       ninstances=ninstances,
       epoch=epoch,
-      **kwargs,
     )
 
     dt = DataTree.from_dict(groups_dict)
@@ -555,7 +558,6 @@ 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"""
@@ -600,7 +602,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.4.0a5 → xarray_ms-0.4.0a6}/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 = [
@@ -57,8 +60,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__ = (
@@ -81,8 +84,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):
@@ -101,7 +104,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.4.0a5 → xarray_ms-0.4.0a6}/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.4.0a5 → xarray_ms-0.4.0a6}/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.4.0a5 → xarray_ms-0.4.0a6}/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.4.0a5/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}