uda-xarray 0.1.0__tar.gz

uda_xarray-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Samuel Jackson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

uda_xarray-0.1.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: uda-xarray
+Version: 0.1.0
+Summary: UDA backend for xarray
+Author-email: Samuel Jackson <samuel.jackson@ukaea.uk>
+Maintainer-email: Samuel Jackson <samuel.jackson@ukaea.uk>
+Project-URL: repository, https://github.com/samueljackson92/uda-xarray
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: uda>=2.9.2
+Requires-Dist: uda-mast
+Requires-Dist: xarray>=2025.12.0
+Dynamic: license-file
+
+# uda-xarray
+
+An xarray backend for UDA (Universal Data Access) that enables seamless integration of UDA data sources with the xarray ecosystem.
+
+## Overview
+
+uda-xarray provides a backend plugin for xarray that allows you to access UDA data sources using xarray's familiar API. It automatically handles the conversion of UDA signals to xarray DataArrays and Datasets, making it easy to work with UDA data in scientific Python workflows.
+
+## Features
+
+- **xarray Integration**: Access UDA data using xarray's `open_dataset` function
+- **Automatic Conversion**: Converts UDA signals to xarray DataArrays with proper coordinates and metadata
+- **Error Handling**: Includes error data alongside signal data
+- **URI-based Access**: Simple URI scheme (`uda://signal_name:shot`) for accessing data
+
+## Installation 
+
+```bash
+pip install uda-xarray
+```
+
+Or using `uv`:
+
+```bash
+uv pip install uda-xarray
+```
+
+## Usage
+
+Open a UDA dataset using xarray:
+
+```python
+import xarray as xr
+
+# Open a UDA signal by name and shot number
+ds = xr.open_dataset("uda://ip:30421", engine="uda")
+
+# Access the data
+data = ds["data"]
+errors = ds["error"]
+
+# The dataset includes time coordinates
+time = ds["time"]
+
+# Access metadata
+units = ds["data"].attrs["units"]
+signal_name = ds["data"].attrs["uda_name"]
+```
+
+The URI format is: `uda://<signal_name>:<shot_number>`
+
+## Data Structure
+
+When you open a UDA dataset, uda-xarray creates an xarray Dataset with:
+
+- **data**: The signal data as a DataArray
+- **error**: The error data as a DataArray
+- **time**: Time coordinates (dimension)
+- **attrs**: Metadata including units and UDA signal name
+
+## Limitations
+
+- Currently only supports 1D signals (2D signals will raise `NotImplementedError`)
+- Requires a working UDA client connection
+
+## Requirements
+
+- Python >= 3.11, < 3.13
+- uda >= 2.9.2
+- xarray >= 2025.12.0
+
+## Development
+
+### Setup
+
+Clone the repository and install development dependencies:
+
+```bash
+git clone https://github.com/samueljackson92/uda-xarray.git
+cd uda-xarray
+uv sync
+```
+
+### Running Tests
+
+```bash
+pytest tests/
+```
+
+### Code Quality
+
+The project uses ruff for linting and formatting, and pylint for additional checks:
+
+```bash
+# Run ruff
+uv run ruff check uda_xarray tests
+uv run ruff format uda_xarray tests
+
+# Run pylint
+uv run pylint uda_xarray
+```
+
+## Contributing
+
+Contributions are welcome! Please ensure:
+
+1. Tests pass for any new functionality
+2. Code follows the project's style guidelines (ruff and pylint)
+3. Documentation is updated as needed
+
+## License
+
+MIT License

uda_xarray-0.1.0/README.md

@@ -0,0 +1,113 @@
+# uda-xarray
+
+An xarray backend for UDA (Universal Data Access) that enables seamless integration of UDA data sources with the xarray ecosystem.
+
+## Overview
+
+uda-xarray provides a backend plugin for xarray that allows you to access UDA data sources using xarray's familiar API. It automatically handles the conversion of UDA signals to xarray DataArrays and Datasets, making it easy to work with UDA data in scientific Python workflows.
+
+## Features
+
+- **xarray Integration**: Access UDA data using xarray's `open_dataset` function
+- **Automatic Conversion**: Converts UDA signals to xarray DataArrays with proper coordinates and metadata
+- **Error Handling**: Includes error data alongside signal data
+- **URI-based Access**: Simple URI scheme (`uda://signal_name:shot`) for accessing data
+
+## Installation 
+
+```bash
+pip install uda-xarray
+```
+
+Or using `uv`:
+
+```bash
+uv pip install uda-xarray
+```
+
+## Usage
+
+Open a UDA dataset using xarray:
+
+```python
+import xarray as xr
+
+# Open a UDA signal by name and shot number
+ds = xr.open_dataset("uda://ip:30421", engine="uda")
+
+# Access the data
+data = ds["data"]
+errors = ds["error"]
+
+# The dataset includes time coordinates
+time = ds["time"]
+
+# Access metadata
+units = ds["data"].attrs["units"]
+signal_name = ds["data"].attrs["uda_name"]
+```
+
+The URI format is: `uda://<signal_name>:<shot_number>`
+
+## Data Structure
+
+When you open a UDA dataset, uda-xarray creates an xarray Dataset with:
+
+- **data**: The signal data as a DataArray
+- **error**: The error data as a DataArray
+- **time**: Time coordinates (dimension)
+- **attrs**: Metadata including units and UDA signal name
+
+## Limitations
+
+- Currently only supports 1D signals (2D signals will raise `NotImplementedError`)
+- Requires a working UDA client connection
+
+## Requirements
+
+- Python >= 3.11, < 3.13
+- uda >= 2.9.2
+- xarray >= 2025.12.0
+
+## Development
+
+### Setup
+
+Clone the repository and install development dependencies:
+
+```bash
+git clone https://github.com/samueljackson92/uda-xarray.git
+cd uda-xarray
+uv sync
+```
+
+### Running Tests
+
+```bash
+pytest tests/
+```
+
+### Code Quality
+
+The project uses ruff for linting and formatting, and pylint for additional checks:
+
+```bash
+# Run ruff
+uv run ruff check uda_xarray tests
+uv run ruff format uda_xarray tests
+
+# Run pylint
+uv run pylint uda_xarray
+```
+
+## Contributing
+
+Contributions are welcome! Please ensure:
+
+1. Tests pass for any new functionality
+2. Code follows the project's style guidelines (ruff and pylint)
+3. Documentation is updated as needed
+
+## License
+
+MIT License

uda_xarray-0.1.0/pyproject.toml

@@ -0,0 +1,70 @@
+[project]
+name = "uda-xarray"
+version = "0.1.0"
+description = "UDA backend for xarray"
+readme = "README.md"
+requires-python = ">=3.11, <3.13"
+authors = [
+    {name = "Samuel Jackson", email = "samuel.jackson@ukaea.uk"},
+]
+maintainers = [
+    {name = "Samuel Jackson", email = "samuel.jackson@ukaea.uk"},
+]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+]
+
+dependencies = [
+    "uda>=2.9.2",
+    "uda-mast",
+    "xarray>=2025.12.0",
+]
+
+[tool.setuptools]
+packages = ["uda_xarray"]
+
+[project.urls]
+repository = "https://github.com/samueljackson92/uda-xarray"
+
+[tool.ruff]
+exclude = []
+
+[dependency-groups]
+dev = [
+    "bump-my-version>=1.2.5",
+    "pylint>=4.0.4",
+    "pytest>=8.4.1",
+    "pytest-mock>=3.15.1",
+    "ruff>=0.14.10",
+]
+
+[project.entry-points."xarray.backends"]
+uda = "uda_xarray.main:UDABackendEntrypoint"
+
+[tool.bumpversion]
+current_version = "0.1.0"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+ignore_missing_files = false
+tag = true
+sign_tags = false
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = false
+commit = true
+message = "Bump version: {current_version} → {new_version}"
+commit_args = ""
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = 'version = "{current_version}"'
+replace = 'version = "{new_version}"'

uda_xarray-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

uda_xarray-0.1.0/tests/test_backend.py

@@ -0,0 +1,150 @@
+import xarray as xr
+import numpy as np
+import pyuda
+from unittest.mock import Mock
+
+
+def test_open_uda_dataset(mocker):
+    # Create mock signal object
+    mock_signal = Mock()
+    mock_signal.data = np.array([1.0, 2.0, 3.0])
+    mock_signal.shape = (3,)
+    dim1 = Mock(label="time")
+    dim1.data = np.array([0.0, 1.0, 2.0])
+    mock_signal.dims = [dim1]
+
+    mock_signal.units = "A"
+    mock_signal.time = Mock()
+    mock_signal.time.data = np.array([0.0, 1.0, 2.0])
+    mock_signal.time.label = "time"
+    mock_signal.errors = Mock()
+    mock_signal.errors.data = np.array([0.1, 0.1, 0.1])
+
+    # Mock the pyuda Client
+    mock_client = Mock()
+    mock_client.get.return_value = mock_signal
+    mocker.patch("pyuda.Client", return_value=mock_client)
+    mocker.patch(
+        "uda_xarray.main.UDABackendEntrypoint._get_signal_type",
+        return_value="Signal",
+    )
+
+    ds = xr.open_dataset("uda://ip:30421", engine="uda")
+
+    # Verify the client was called correctly
+    mock_client.get.assert_called_once_with("ip", 30421)
+
+    assert ds["data"].name == "data"
+    assert ds["data"].dims == ("time",)
+    assert "time" in ds.coords
+
+    assert ds["data"].shape == ds["time"].shape
+    assert "units" in ds["data"].attrs
+    assert ds["data"].attrs["uda_name"] == "ip"
+
+
+def test_open_uda_dataset_2d(mocker):
+    # Create mock 2D signal object
+    mock_signal = Mock()
+    mock_signal.data = np.array([[1.0, 2.0], [3.0, 4.0]])
+    mock_signal.shape = (2, 2)
+    dim1 = Mock(label="time")
+    dim1.data = np.array([0.0, 1.0])
+    dim2 = Mock(label="channel")
+    dim2.data = np.array([0, 1])
+    mock_signal.dims = [dim1, dim2]
+    mock_signal.units = "eV"
+    mock_signal.errors = Mock()
+    mock_signal.errors.data = np.array([[0.1, 0.1], [0.1, 0.1]])
+    mock_signal.time = Mock()
+    mock_signal.time.data = np.array([0.0, 1.0])
+    mock_signal.time.label = "time"
+
+    # Mock the pyuda Client
+    mock_client = Mock()
+    mock_client.get.return_value = mock_signal
+    mocker.patch("pyuda.Client", return_value=mock_client)
+    mocker.patch(
+        "uda_xarray.main.UDABackendEntrypoint._get_signal_type",
+        return_value="Signal",
+    )
+
+    ds = xr.open_dataset("uda://AYE_TE:30421", engine="uda")
+
+    mock_client.get.assert_called_once_with("AYE_TE", 30421)
+
+    assert ds["data"].name == "data"
+    assert ds["data"].dims == ("channel", "time")
+    assert "time" in ds.coords
+    assert "channel" in ds.coords
+
+
+def test_open_uda_dataset_video(mocker):
+    mock_signal = Mock()
+    mock_signal.is_color = False
+    mock_signal.frame_times = np.array([0.0, 0.033, 0.066])
+    frame1 = Mock()
+    frame1.k = np.array([[10, 20], [30, 40]])
+    frame2 = Mock()
+    frame2.k = np.array([[15, 25], [35, 45]])
+    frame3 = Mock()
+    frame3.k = np.array([[20, 30], [40, 50]])
+    mock_signal.frames = [frame1, frame2, frame3]
+    mock_signal.height = 2
+    mock_signal.width = 2
+    mock_signal.duration = 0.066
+    mock_signal.num_frames = 3
+    mock_signal.name = "rba"
+    mock_signal.description = "Mock video signal"
+    mock_signal.units = "counts"
+
+    mock_client = Mock()
+    mock_client.get_images.return_value = mock_signal
+    mocker.patch("pyuda.Client", return_value=mock_client)
+    mocker.patch(
+        "uda_xarray.main.UDABackendEntrypoint._get_signal_type",
+        return_value="Image",
+    )
+
+    ds = xr.open_dataset("uda://rba:30421", engine="uda")
+    assert ds["data"].name == "data"
+    assert ds["data"].dims == ("time", "height", "width")
+    assert "time" in ds.coords
+    assert ds.sizes["time"] == 3
+
+
+def test_open_uda_dataset_invalid_signal(mocker):
+    # Mock the pyuda Client to raise an exception
+    mock_client = Mock()
+    mock_client.get.side_effect = pyuda.ServerException("Signal not found")
+    mocker.patch("pyuda.Client", return_value=mock_client)
+    mocker.patch(
+        "uda_xarray.main.UDABackendEntrypoint._get_signal_type",
+        return_value="Signal",
+    )
+
+    try:
+        xr.open_dataset("uda://invalid_signal:99999", engine="uda")
+    except RuntimeError as e:
+        assert "Could not open UDA dataset" in str(e)
+    else:
+        assert False, "Expected RuntimeError was not raised"
+
+
+def test_open_uda_dataset_invalid_format():
+    try:
+        xr.open_dataset("invalid_format", engine="uda")
+    except ValueError as e:
+        assert (
+            "UDA dataset must be specified as uda://<signal_name>:<shot_number>"
+            in str(e)
+        )
+    else:
+        assert False, "Expected ValueError was not raised"
+
+    try:
+        xr.open_dataset("http://invalid_scheme:12345", engine="uda")
+    except ValueError as e:
+        assert "UDA dataset must start with the uda:// scheme" in str(e)
+    else:
+        assert False, "Expected ValueError was not raised"

uda_xarray-0.1.0/uda_xarray/main.py

@@ -0,0 +1,164 @@
+"""Xarray UDA backend entrypoint."""
+
+from enum import Enum
+from typing import Optional
+
+import numpy as np
+import pyuda
+import xarray as xr
+from mast.mast_client import ListType
+from xarray.backends import BackendEntrypoint
+
+
+class SignalType(str, Enum):
+    """Enum for UDA signal types."""
+
+    SIGNAL = "Signal"
+    IMAGE = "Image"
+
+
+Signal = pyuda.Signal
+Video = pyuda.Video
+
+
+class UDABackendEntrypoint(BackendEntrypoint):
+    """Xarray UDA backend entrypoint."""
+
+    def open_dataset(
+        self,
+        filename_or_obj,
+        *,
+        drop_variables=None,
+        frame_number: Optional[int] = None,  # noqa: F821
+    ) -> xr.Dataset:
+        """Open a UDA dataset given a signal name and shot number.
+
+        Parameters
+        ----------
+        filename_or_obj : str
+            UDA dataset specified as uda://<signal_name>:<shot_number>
+        drop_variables : list, optional
+            Variables to drop from the dataset (not used).
+        frame_number : int, optional
+            Frame number to extract from an image signal (if applicable).
+        """
+
+        if ":" not in filename_or_obj:
+            raise ValueError(
+                "UDA dataset must be specified as uda://<signal_name>:<shot_number>"
+            )
+
+        if "uda://" not in filename_or_obj:
+            raise ValueError("UDA dataset must start with the uda:// scheme")
+
+        name, shot = filename_or_obj.rsplit(":", maxsplit=1)
+        name = name.replace("uda://", "")
+        shot = int(shot)
+
+        client = pyuda.Client()
+        signal_type = self._get_signal_type(client, name, shot)
+
+        try:
+            if signal_type == SignalType.SIGNAL:
+                signal = client.get(name, shot)
+                dataset = self._handle_signal(name, signal)
+            elif signal_type == SignalType.IMAGE:
+                kwargs = {}
+                if frame_number is not None:
+                    kwargs["frame_number"] = frame_number
+                signal = client.get_images(name, shot, **kwargs)
+                dataset = self._handle_images(name, signal, frame_number=frame_number)
+            else:
+                raise NotImplementedError(f"Signal type {signal_type} not supported")
+        # pylint: disable=c-extension-no-member
+        except (pyuda.ServerException, pyuda.cpyuda.ClientException) as e:
+            raise RuntimeError(f"Could not open UDA dataset {filename_or_obj}") from e
+
+        return dataset
+
+    def _handle_signal(self, name: str, signal: Signal) -> xr.Dataset:
+        dim_data = {dim.label: dim.data for dim in signal.dims}
+
+        # Rename time dimension to just "time" if we can.
+        if signal.time.label in dim_data:
+            dim_data["time"] = dim_data.pop(signal.time.label)
+
+        item = xr.DataArray(
+            signal.data,
+            coords=dim_data,
+            attrs={"units": signal.units, "uda_name": name},
+        )
+
+        error = xr.DataArray(
+            signal.errors.data,
+            coords=dim_data,
+        )
+
+        dataset = xr.Dataset(data_vars={"data": item, "error": error})
+        return dataset
+
+    def _handle_images(
+        self, name: str, video: Video, frame_number: Optional[int] = None
+    ) -> xr.Dataset:
+        attrs = {
+            name: getattr(video, name)
+            for name in dir(video)
+            if not name.startswith("_") and not callable(getattr(video, name))
+        }
+
+        attrs.pop("frame_times")
+        attrs.pop("frames")
+
+        attrs["CLASS"] = "IMAGE"
+        attrs["IMAGE_VERSION"] = "1.2"
+
+        time = np.atleast_1d(video.frame_times)
+        if frame_number is not None:
+            time = time[frame_number : frame_number + 1]
+        coords = {"time": xr.DataArray(time, dims=["time"], attrs={"units": "s"})}
+
+        if video.is_color:
+            frames = [np.dstack((frame.r, frame.g, frame.b)) for frame in video.frames]
+            frames = np.stack(frames)
+            if frames.shape[1] != video.height:
+                frames = np.swapaxes(frames, 1, 2)
+            dim_names = ["time", "height", "width", "channel"]
+
+            attrs["IMAGE_SUBCLASS"] = "IMAGE_TRUECOLOR"
+            attrs["INTERLACE_MODE"] = "INTERLACE_PIXEL"
+        else:
+            frames = [frame.k for frame in video.frames]
+            frames = np.stack(frames)
+            frames = np.atleast_3d(frames)
+            if frames.shape[1] != video.height:
+                frames = np.swapaxes(frames, 1, 2)
+            dim_names = ["time", "height", "width"]
+
+            attrs["IMAGE_SUBCLASS"] = "IMAGE_INDEXED"
+
+        dataset = xr.DataArray(frames, dims=dim_names, coords=coords, attrs=attrs)
+        dataset = dataset.to_dataset(name="data")
+        dataset.attrs["uda_name"] = name
+        return dataset
+
+    def _get_signal_type(
+        self, client: pyuda.Client, name: str, shot: int
+    ) -> SignalType:
+        sources = client.list(ListType.SOURCES, shot=shot)
+        source_types = {s.source_alias: s.type for s in sources}
+
+        if name in source_types and source_types[name] == "Image":
+            return SignalType.IMAGE
+        return SignalType.SIGNAL
+
+    def open_datatree(self, filename_or_obj, *, drop_variables=None):
+        raise NotImplementedError("UDA backend does not support open_datatree")
+
+    open_dataset_parameters = ["filename_or_obj", "drop_variables"]
+
+    def guess_can_open(self, filename_or_obj):
+        return filename_or_obj.startswith("uda://")
+
+    description = "Use UDA data in Xarray"
+
+    url = "https://github.com/samueljackson92/uda-xarray"

uda_xarray-0.1.0/uda_xarray.egg-info/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: uda-xarray
+Version: 0.1.0
+Summary: UDA backend for xarray
+Author-email: Samuel Jackson <samuel.jackson@ukaea.uk>
+Maintainer-email: Samuel Jackson <samuel.jackson@ukaea.uk>
+Project-URL: repository, https://github.com/samueljackson92/uda-xarray
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: uda>=2.9.2
+Requires-Dist: uda-mast
+Requires-Dist: xarray>=2025.12.0
+Dynamic: license-file
+
+# uda-xarray
+
+An xarray backend for UDA (Universal Data Access) that enables seamless integration of UDA data sources with the xarray ecosystem.
+
+## Overview
+
+uda-xarray provides a backend plugin for xarray that allows you to access UDA data sources using xarray's familiar API. It automatically handles the conversion of UDA signals to xarray DataArrays and Datasets, making it easy to work with UDA data in scientific Python workflows.
+
+## Features
+
+- **xarray Integration**: Access UDA data using xarray's `open_dataset` function
+- **Automatic Conversion**: Converts UDA signals to xarray DataArrays with proper coordinates and metadata
+- **Error Handling**: Includes error data alongside signal data
+- **URI-based Access**: Simple URI scheme (`uda://signal_name:shot`) for accessing data
+
+## Installation 
+
+```bash
+pip install uda-xarray
+```
+
+Or using `uv`:
+
+```bash
+uv pip install uda-xarray
+```
+
+## Usage
+
+Open a UDA dataset using xarray:
+
+```python
+import xarray as xr
+
+# Open a UDA signal by name and shot number
+ds = xr.open_dataset("uda://ip:30421", engine="uda")
+
+# Access the data
+data = ds["data"]
+errors = ds["error"]
+
+# The dataset includes time coordinates
+time = ds["time"]
+
+# Access metadata
+units = ds["data"].attrs["units"]
+signal_name = ds["data"].attrs["uda_name"]
+```
+
+The URI format is: `uda://<signal_name>:<shot_number>`
+
+## Data Structure
+
+When you open a UDA dataset, uda-xarray creates an xarray Dataset with:
+
+- **data**: The signal data as a DataArray
+- **error**: The error data as a DataArray
+- **time**: Time coordinates (dimension)
+- **attrs**: Metadata including units and UDA signal name
+
+## Limitations
+
+- Currently only supports 1D signals (2D signals will raise `NotImplementedError`)
+- Requires a working UDA client connection
+
+## Requirements
+
+- Python >= 3.11, < 3.13
+- uda >= 2.9.2
+- xarray >= 2025.12.0
+
+## Development
+
+### Setup
+
+Clone the repository and install development dependencies:
+
+```bash
+git clone https://github.com/samueljackson92/uda-xarray.git
+cd uda-xarray
+uv sync
+```
+
+### Running Tests
+
+```bash
+pytest tests/
+```
+
+### Code Quality
+
+The project uses ruff for linting and formatting, and pylint for additional checks:
+
+```bash
+# Run ruff
+uv run ruff check uda_xarray tests
+uv run ruff format uda_xarray tests
+
+# Run pylint
+uv run pylint uda_xarray
+```
+
+## Contributing
+
+Contributions are welcome! Please ensure:
+
+1. Tests pass for any new functionality
+2. Code follows the project's style guidelines (ruff and pylint)
+3. Documentation is updated as needed
+
+## License
+
+MIT License

uda_xarray-0.1.0/uda_xarray.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+tests/test_backend.py
+uda_xarray/main.py
+uda_xarray.egg-info/PKG-INFO
+uda_xarray.egg-info/SOURCES.txt
+uda_xarray.egg-info/dependency_links.txt
+uda_xarray.egg-info/entry_points.txt
+uda_xarray.egg-info/requires.txt
+uda_xarray.egg-info/top_level.txt

uda_xarray-0.1.0/uda_xarray.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

uda_xarray-0.1.0/uda_xarray.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[xarray.backends]
+uda = uda_xarray.main:UDABackendEntrypoint

uda_xarray-0.1.0/uda_xarray.egg-info/requires.txt

@@ -0,0 +1,3 @@
+uda>=2.9.2
+uda-mast
+xarray>=2025.12.0

uda_xarray-0.1.0/uda_xarray.egg-info/top_level.txt

@@ -0,0 +1 @@
+uda_xarray