uda-xarray 0.3.0__tar.gz → 0.3.1__tar.gz

{uda_xarray-0.3.0/uda_xarray.egg-info → uda_xarray-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uda-xarray
-Version: 0.3.0
+Version: 0.3.1
 Summary: UDA backend for xarray
 Author-email: Samuel Jackson <samuel.jackson@ukaea.uk>
 Maintainer-email: Samuel Jackson <samuel.jackson@ukaea.uk>
@@ -9,8 +9,10 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: MIT License
-Requires-Python: <3.13,>=3.9
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: uda>=2.9.2

{uda_xarray-0.3.0 → uda_xarray-0.3.1}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "uda-xarray"
-version = "0.3.0"
+version = "0.3.1"
 description = "UDA backend for xarray"
 readme = "README.md"
-requires-python = ">=3.9, <3.13"
+requires-python = ">=3.9"
 authors = [
     {name = "Samuel Jackson", email = "samuel.jackson@ukaea.uk"},
 ]
@@ -16,6 +16,8 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "License :: OSI Approved :: MIT License",
 ]
 
@@ -51,7 +53,7 @@ dev = [
 uda = "uda_xarray.main:UDABackendEntrypoint"
 
 [tool.bumpversion]
-current_version = "0.3.0"
+current_version = "0.3.1"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{uda_xarray-0.3.0 → uda_xarray-0.3.1}/tests/test_backend.py

@@ -288,7 +288,7 @@ def test_open_datatree_video(mocker):
     assert ds.sizes["time"] == 3
 
 
-@pytest.mark.skip(reason="Requires access to real UDA server with video data")
+@pytest.mark.live
 def test_open_uda_dataset_video_frame():
     """Test loading a single video frame from a real UDA server."""
     ds = xr.open_dataset(
@@ -300,14 +300,14 @@ def test_open_uda_dataset_video_frame():
     assert ds.sizes["time"] == 1
 
 
-@pytest.mark.skip(reason="Requires access to real UDA server with video data")
+@pytest.mark.live
 def test_real_data_2d():
     """Test loading real 2D data from a live UDA server."""
     ds = xr.open_dataset("uda://AYE_TE:30421", engine="uda")
     assert ds["data"].name == "data"
-    assert ds["data"].dims == ("time", "radial_index")
+    assert ds["data"].dims == ("time", "radial index")
     assert "time" in ds.coords
-    assert "radial_index" in ds.coords
+    assert "radial index" in ds.coords
 
 
 def test_remapped_signal_uses_legacy_name(mocker):
@@ -507,3 +507,28 @@ def test_unmapped_signal_passes_through(mocker):
 
     mock_client.get.assert_called_once_with("SOME_UNKNOWN_SIGNAL", 30421)
     assert ds["data"].attrs["uda_name"] == "SOME_UNKNOWN_SIGNAL"
+
+
+def test_resolve_ignores_case_and_leading_slash():
+    mappings = SignalMappings(
+        mappings={
+            "/ESM/VLOOP/DYNAMIC": [
+                SignalRange(shot_min=1, shot_max=10, name="/ESM/VLOOP_DYNAMIC")
+            ]
+        }
+    )
+    for name in ("/ESM/VLOOP/DYNAMIC", "esm/vloop/dynamic", "/esm/vloop/dynamic"):
+        assert mappings.resolve(name, 5) == "/ESM/VLOOP_DYNAMIC"
+    assert mappings.resolve("esm/vloop/dynamic", 11) is None
+
+
+def test_bundled_mastu_renames():
+    mappings = SignalMappings.from_file()
+    # Shot with only the old name in the catalogue.
+    assert mappings.resolve("esm/vloop/dynamic", 43477) == "/ESM/VLOOP_DYNAMIC"
+    assert mappings.resolve("esm/density/nebar", 43482) == "/ESM/NEBAR"
+    assert mappings.resolve("xdc/ai/cpu1/rogext_TF", 40240) == "/XDC/AI/CPU1/TF_CURRENT"
+    # Shots with the new name are not remapped.
+    assert mappings.resolve("esm/vloop/dynamic", 43478) is None
+    assert mappings.resolve("esm/vloop/dynamic", 52000) is None
+    assert mappings.resolve("xdc/ai/cpu1/rogext_TF", 40300) is None

uda_xarray-0.3.1/tests/test_mastu_mappings_live.py

@@ -0,0 +1,72 @@
+"""Live tests for the MAST-U signal mappings in ``mastu.json``.
+
+These tests read real data, so they need a UDA server. ``conftest.py`` skips them when the
+server cannot be reached (for example on CI). Run them from a machine with UDA access.
+"""
+
+import pytest
+import xarray as xr
+
+from uda_xarray.mappings import SignalMappings
+
+# Renamed signals. The key is the current name. A shot with the current name needs no mapping.
+RENAMED = (
+    "/ESM/VLOOP/DYNAMIC",
+    "/ESM/VLOOP/STATIC",
+    "/ESM/DENSITY/NEBAR",
+    "/ESM/DENSITY/NG",
+    "/ESM/DENSITY/FG",
+    "/ESM/POWER/POHM",
+    "/XDC/AI/CPU1/ROGEXT_TF",
+)
+# Shots that have the current name of every signal in RENAMED, and are not in a mapped range.
+# 47000 has both the old and the current names. 52002 is after the old names end (shot 51257).
+CURRENT_NAME_SHOTS = (47000, 52002)
+# Number of shots to read for each signal. Each read takes a few seconds.
+SAMPLES_PER_SIGNAL = 5
+
+
+pytestmark = pytest.mark.live
+
+MAPPINGS = SignalMappings.from_file()
+
+
+def _sample_shots(signal: str) -> list[int]:
+    """Return shots spread over the mapped ranges, including the first and the last."""
+    ranges = sorted(MAPPINGS.mappings[signal], key=lambda r: r.shot_min)
+    shots = [ranges[0].shot_min, ranges[-1].shot_max]
+    step = max(1, len(ranges) // (SAMPLES_PER_SIGNAL - 1))
+    shots += [r.shot_min for r in ranges[::step]]
+    return sorted(set(shots))[: SAMPLES_PER_SIGNAL + 1]
+
+
+def _open(name: str, shot: int) -> xr.Dataset:
+    return xr.open_dataset(f"uda://{name}:{shot}", engine="uda")
+
+
+def _cases() -> list[tuple[str, int]]:
+    return [(signal, shot) for signal in RENAMED for shot in _sample_shots(signal)]
+
+
+@pytest.mark.parametrize(("signal", "shot"), _cases())
+def test_mapped_shot_returns_data_under_old_name(signal, shot):
+    """The current name is read from the old name in a mapped shot."""
+    old_name = MAPPINGS.resolve(signal, shot)
+    assert old_name is not None
+
+    dataset = _open(signal.lstrip("/").lower(), shot)
+
+    assert dataset["data"].size > 0
+    assert dataset["data"].attrs["uda_name"] == old_name
+
+
+@pytest.mark.parametrize("shot", CURRENT_NAME_SHOTS)
+@pytest.mark.parametrize("signal", RENAMED)
+def test_current_name_shot_is_not_remapped(signal, shot):
+    """A shot with the current name is not remapped, and still returns data."""
+    assert MAPPINGS.resolve(signal, shot) is None
+
+    dataset = _open(signal.lstrip("/").lower(), shot)
+
+    assert dataset["data"].size > 0
+    assert dataset["data"].attrs["uda_name"].lstrip("/").upper() == signal.lstrip("/")

{uda_xarray-0.3.0 → uda_xarray-0.3.1}/uda_xarray/mappings.py

@@ -6,7 +6,15 @@ import importlib.resources
 import json
 from typing import Iterator
 
-from pydantic import BaseModel
+from pydantic import BaseModel, PrivateAttr
+
+
+def _normalise(name: str) -> str:
+    """Return *name* without a leading slash and in upper case.
+
+    UDA matches signal names without regard to case, and with or without the leading slash.
+    """
+    return name.lstrip("/").upper()
 
 
 class SignalRange(BaseModel):
@@ -31,6 +39,7 @@ class SignalMappings(BaseModel):
     """
 
     mappings: dict[str, list[SignalRange]]
+    _index: dict[str, list[SignalRange]] | None = PrivateAttr(default=None)
 
     @classmethod
     def from_file(cls, path: str | None = None) -> "SignalMappings":
@@ -63,7 +72,7 @@ class SignalMappings(BaseModel):
         Returns *None* if *signal* is not in the mapping or no range covers
         the shot.
         """
-        ranges = self.mappings.get(signal)
+        ranges = self._normalised().get(_normalise(signal))
         if ranges is None:
             return None
         for r in ranges:
@@ -71,6 +80,15 @@ class SignalMappings(BaseModel):
                 return r.name
         return None
 
+    def _normalised(self) -> dict[str, list[SignalRange]]:
+        """Return the mappings keyed by normalised signal name (built once)."""
+        if self._index is None:
+            index: dict[str, list[SignalRange]] = {}
+            for key, ranges in self.mappings.items():
+                index.setdefault(_normalise(key), []).extend(ranges)
+            self._index = index
+        return self._index
+
     def __iter__(self) -> Iterator[tuple[str, list[SignalRange]]]:
         return iter(self.mappings.items())