xradio 1.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

xradio/schema/check.py

@@ -7,7 +7,6 @@ import warnings
 
 import xarray
 import numpy
-from typeguard import check_type, TypeCheckError
 
 from xradio.schema import (
     metamodel,
@@ -502,38 +501,90 @@ def _check_value(val: typing.Any, schema: metamodel.ValueSchema):
                     ]
                 )
 
-        if not isinstance(val, xarray.DataArray):
-            # Fall through to plain type check
-            type_to_check = xarray.DataArray
-        else:
+        if isinstance(val, xarray.DataArray):
             return check_array(val, schema.array_schema)
 
+        expected = [xarray.DataArray]
+        if schema.optional:
+            expected.append(type(None))
+        return SchemaIssues(
+            [
+                SchemaIssue(
+                    path=[],
+                    message=f"{type(val).__name__} is not an xarray.DataArray!",
+                    expected=expected,
+                    found=type(val),
+                )
+            ]
+        )
+
     # Is supposed to be a dictionary?
     elif schema.type == "dict":
         if not isinstance(val, dict):
-            # Fall through to plain type check
-            type_to_check = dict
+            expected = [dict]
+            if schema.optional:
+                expected.append(type(None))
+            return SchemaIssues(
+                [
+                    SchemaIssue(
+                        path=[],
+                        message=f"{type(val).__name__} is not a dictionary!",
+                        expected=expected,
+                        found=type(val),
+                    )
+                ]
+            )
         else:
             return check_dict(val, schema.dict_schema)
 
     elif schema.type == "list[str]":
-        type_to_check = typing.List[str]
+        if not isinstance(val, list):
+            expected = [list[str]]
+            if schema.optional:
+                expected.append(type(None))
+            return SchemaIssues(
+                [
+                    SchemaIssue(
+                        path=[],
+                        message=f"{type(val).__name__} is not a list!",
+                        expected=expected,
+                        found=type(val),
+                    )
+                ]
+            )
+        if any(type(v) is not str for v in val):
+            expected = [list[str]]
+            if schema.optional:
+                expected.append(type(None))
+            return SchemaIssues(
+                [
+                    SchemaIssue(
+                        path=[],
+                        message=f"{type(val).__name__} is not a list of strings!",
+                        expected=expected,
+                        found=type(val),
+                    )
+                ]
+            )
     elif schema.type in ["bool", "str", "int", "float"]:
         type_to_check = getattr(builtins, schema.type)
+        if not isinstance(val, type_to_check):
+            expected = [type_to_check]
+            if schema.optional:
+                expected.append(type(None))
+            return SchemaIssues(
+                [
+                    SchemaIssue(
+                        path=[],
+                        message=f"{type(val).__name__} is not a {schema.type}!",
+                        expected=expected,
+                        found=type(val),
+                    )
+                ]
+            )
     else:
         raise ValueError(f"Invalid typ_name in schema: {schema.type}")
 
-    # Otherwise straight type check using typeguard
-    try:
-        check_type(val, type_to_check)
-    except TypeCheckError as t:
-        expected = [type_to_check]
-        if schema.optional:
-            expected.append(type(None))
-        return SchemaIssues(
-            [SchemaIssue(path=[], message=str(t), expected=expected, found=type(val))]
-        )
-
     # List of literals given?
     if schema.literal is not None:
         for lit in schema.literal:

xradio/schema/common.py

@@ -9,7 +9,6 @@ from xradio.schema.bases import (
 from xradio.schema.typing import Attr, Coord, Coordof, Data, Dataof, Name
 import numpy
 
-
 # Dimensions
 Time = Literal["time"]
 """ Observation time dimension """

xradio/testing/_utils/__template__.py

@@ -0,0 +1,58 @@
+import pytest
+import xarray as xr
+
+from xradio.measurement_set import load_processing_set
+from xradio.schema.check import check_datatree
+
+from xradio.measurement_set.measurement_set_xdt import (
+    MeasurementSetXdt,
+    InvalidAccessorLocation,
+)
+
+
+def test_simple():
+    assert True
+
+
+def test_simple_string(sample_fixture):
+    print(f"Sample fixture value: {sample_fixture}")
+    assert sample_fixture == "sample_data"
+
+
+def test_sel():
+    ms_xdt = MeasurementSetXdt(xr.DataTree())
+
+    with pytest.raises(InvalidAccessorLocation, match="not a MSv4 node"):
+        assert ms_xdt.sel()
+
+
+class TestLoadProcessingSet:
+    """Tests for load_processing_set using real data"""
+
+    # This is a simple test to ensure that pytest is working correctly.
+    # It should be run with pytest to verify that the testing framework is set up properly.
+    def test_pytest_setup(self):
+        """A simple test to ensure pytest is set up correctly."""
+        assert True, "Pytest setup is working correctly."
+
+    @pytest.mark.parametrize(
+        "convert_measurement_set_to_processing_set",
+        ["Antennae_North.cal.lsrk.split.ms"],
+        indirect=True,
+    )
+    def test_check_datatree(self, convert_measurement_set_to_processing_set):
+        """Test that the converted MS to PS complies with the datatree schema checker"""
+        ps_xdt = load_processing_set(str(convert_measurement_set_to_processing_set))
+        issues = check_datatree(ps_xdt)
+        # The check_datatree function returns a SchemaIssues object, not a string
+        assert (
+            str(issues) == "No schema issues found"
+        ), f"Schema validation failed: {issues}"
+
+
+if __name__ == "__main__":
+    pytest.main(["-v", "-s", __file__])
+# This is a simple test to ensure that pytest is working correctly.
+# It should be run with pytest to verify that the testing framework is set up properly.
+# To run this test, use the command: pytest -v __test_example__.py
+# This will execute the test and show the results in verbose mode.

xradio/testing/measurement_set/__init__.py

@@ -0,0 +1,58 @@
+"""
+Test utilities for xradio - usable in both pytest and ASV benchmarks.
+
+This module provides reusable test utilities for generating test data,
+custom assertions, and helper functions for testing xradio functionality.
+"""
+
+import toolviper.utils.logger as _logger
+
+__all__ = [
+    # Generators
+    "gen_test_ms",
+    "make_ms_empty",
+    "gen_minimal_ms",
+    # Validators
+    "check_msv4_matches_descr",
+    "check_processing_set_matches_msv2_descr",
+    # IO helpers
+    "download_measurement_set",
+    "build_processing_set_from_msv2",
+    "build_msv4_partition",
+    "build_minimal_msv4_xdt",
+]
+
+# Export validators
+from xradio.testing.measurement_set.checker import (
+    check_msv4_matches_descr,
+    check_processing_set_matches_msv2_descr,
+)
+
+# Export IO helpers (non-casacore dependent)
+from xradio.testing.measurement_set.io import (
+    download_measurement_set,
+)
+
+# Casacore-dependent imports (with fallback)
+try:
+    # Export generators
+    from xradio.testing.measurement_set.msv2_io import (
+        gen_test_ms,
+        make_ms_empty,
+        gen_minimal_ms,
+    )
+
+    # Export IO helpers (casacore-dependent)
+    from xradio.testing.measurement_set.msv2_io import (
+        build_processing_set_from_msv2,
+        build_msv4_partition,
+        build_minimal_msv4_xdt,
+    )
+except ModuleNotFoundError as exc:
+    _logger.warning(
+        "Could not import casacore tables to handle MSv2. "
+        "Could not import the functions to convert from MSv2 to MSv4. "
+        f"That functionality will not be available. Details: {exc}"
+    )
+else:
+    __all__.extend(["convert_msv2_to_processing_set"])

xradio/testing/measurement_set/checker.py

@@ -0,0 +1,131 @@
+"""
+Checks that an MSv4 converted from a generated MSv2 (gen_test_ms) has:
+ - the expected sizes
+ - input IDs (for antennas, fields, scans, etc.)
+ - data column
+ - etc. structure
+of the generated MSv2 given as input to the MSv2=>MSv4 converter.
+"""
+
+import numpy as np
+import xarray as xr
+
+
+def check_msv4_matches_descr(msv4_xdt, msv2_descr):
+    """
+    Checks a single partition / MSv4
+
+    Parameters
+    ----------
+    msv4_xdt : xr.DataTree
+        An MSv4 DataTree containing one MSv4 partition
+
+    msv2_descr : dict
+        MSv2 description that was used to generate a test input MSv2 in gen_test_ms
+
+    """
+    msv2_to_msv4_data_colname = {
+        "DATA": "VISIBILITY",
+        "MODEL_DATA": "VISIBILITY_MODEL",
+        "CORRECTED_DATA": "VISIBILITY_CORRECTED",
+    }
+
+    msv4_xds = msv4_xdt.ds
+    assert (msv2_descr["nrows_per_ddi"],) == msv4_xds.time.shape
+    nantennas = len(msv2_descr["ANTENNA"])
+    nbaselines = int(nantennas * (nantennas - 1) / 2)
+    assert (nbaselines,) == msv4_xds.baseline_id.shape
+    assert (msv2_descr["nchans"],) == msv4_xds.frequency.shape
+    assert (msv2_descr["nchans"],) == msv4_xds.frequency.shape
+    assert (msv2_descr["npols"],) == msv4_xds.polarization.shape
+
+    assert "scan_name" in msv4_xds
+    assert len(np.unique(msv4_xds.coords["scan_name"])) == 1
+
+    for msv2_data_colname in msv2_descr["data_cols"]:
+        msv4_data_colname = msv2_to_msv4_data_colname[msv2_data_colname]
+        assert msv4_data_colname in msv4_xds.data_vars
+
+        data_shape = msv4_xds.data_vars[msv4_data_colname].shape
+        assert msv2_descr["nrows_per_ddi"] == data_shape[0]
+        assert nbaselines == data_shape[1]
+        assert msv2_descr["nchans"] == data_shape[2]
+        assert msv2_descr["npols"] == data_shape[3]
+
+    ant_xds = msv4_xdt["antenna_xds"].ds
+    assert "antenna_name" in ant_xds
+    assert len(ant_xds.coords["antenna_name"]) == nantennas
+
+    if msv2_descr["params"]["misbehave"]:
+        expected_type = "field_and_source"
+    else:
+        expected_type = "field_and_source_ephemeris"
+
+    field_and_source_name = "field_and_source_base_xds"
+    assert (
+        field_and_source_name
+        == msv4_xdt.ds.attrs["data_groups"]["base"]["field_and_source"]
+    )
+    assert field_and_source_name in msv4_xdt
+    assert msv4_xdt[field_and_source_name].ds.attrs["type"] == expected_type
+
+    if msv2_descr["params"]["opt_tables"]:
+        assert "system_calibration_xds" in msv4_xdt
+        assert "weather_xds" in msv4_xdt
+        if not msv2_descr["params"]["misbehave"]:
+            assert "SOURCE_DIRECTION" in msv4_xdt["field_and_source_base_xds"].ds
+            assert (
+                msv4_xdt["field_and_source_base_xds"].attrs["type"]
+                == "field_and_source_ephemeris"
+            )
+
+    if msv2_descr["params"]["vlbi_tables"]:
+        assert "gain_curve_xds" in msv4_xdt
+        assert "phase_calibration_xds" in msv4_xdt
+
+    partition_info = msv4_xdt.xr_ms.get_partition_info()
+    processor_info = msv4_xdt.ds.attrs["processor_info"]
+    if msv2_descr["params"]["misbehave"]:
+        # SPW names should be empty string in MSv2
+        assert partition_info["spectral_window_name"] == "spw_0"
+        assert not processor_info["type"]
+        assert not processor_info["sub_type"]
+    else:
+        assert partition_info["spectral_window_name"]
+        assert processor_info["type"]
+        assert processor_info["sub_type"]
+
+    observation_info = msv4_xdt.ds.attrs["observation_info"]
+    if msv2_descr["params"]["opt_tables"] and not msv2_descr["params"]["misbehave"]:
+        assert "session_reference_UID" in observation_info
+    else:
+        assert "session_reference_UID" not in observation_info
+
+    if (
+        (msv2_descr["params"]["opt_tables"] and not msv2_descr["params"]["misbehave"])
+    ) or "OBSERVATION" in msv2_descr:
+        assert "execution_block_UID" in observation_info
+        assert "scheduling_block_UID" in observation_info
+    else:
+        assert "execution_block_UID" not in observation_info
+        assert "scheduling_block_UID" not in observation_info
+
+
+def check_processing_set_matches_msv2_descr(
+    proc_set_xdt: xr.DataTree, msv2_descr: dict
+):
+    """
+    Parameters
+    ----------
+    proc_set_xdt : xr.DataTree
+        A processing set DataTree containing MSv4s to be checked
+
+    msv2_descr : dict
+        MSv2 description that was used to generate a test input MSv2 in gen_test_ms
+
+    Returns
+    -------
+
+    """
+    for _msv4_name, msv4_xdt in proc_set_xdt.items():
+        check_msv4_matches_descr(msv4_xdt, msv2_descr)

xradio/testing/measurement_set/io.py

@@ -0,0 +1,22 @@
+"""
+I/O helpers to download reusable MeasurementSets.
+
+Casacore-dependent functions have been moved to msv2_io.py.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from toolviper.utils.data import download
+
+
+def download_measurement_set(input_ms: str, directory: str | Path = "/tmp") -> Path:
+    """
+    Download a MeasurementSet v2 archive into the given directory.
+    """
+
+    directory = Path(directory)
+    directory.mkdir(parents=True, exist_ok=True)
+    download(file=input_ms, folder=str(directory))
+    return directory / input_ms