sal-xarray 0.1.0__tar.gz

sal_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.

sal_xarray-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: sal-xarray
+Version: 0.1.0
+Summary: SAL 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/sal-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: numpy<2
+Requires-Dist: sal>=1.2.5
+Requires-Dist: xarray>=2025.12.0
+Dynamic: license-file
+
+# sal-xarray
+
+An xarray backend for SAL (Simple Access Layer) that enables seamless integration of SAL data sources with the xarray ecosystem.
+
+## Overview
+
+sal-xarray provides a backend plugin for xarray that allows you to access SAL data sources using xarray's familiar API. It automatically handles the conversion of SAL signals to xarray DataArrays and Datasets, making it easy to work with SAL data in scientific Python workflows.
+## Features
+
+- **xarray Integration**: Access SAL data using xarray's `open_dataset` function
+- **Automatic Conversion**: Converts SAL signals to xarray DataArrays with proper coordinates and metadata
+- **Status Mask Handling**: Includes status mask data alongside signal data
+- **URI-based Access**: Simple URI scheme (`sal://pulse/<shot_number>/<signal_name>`) for accessing data
+
+## Installation 
+
+```bash
+pip install sal-xarray
+```
+
+Or using `uv`:
+
+```bash
+uv pip install sal-xarray
+```
+
+## Usage
+
+Open a SAL dataset using xarray:
+
+```python
+import xarray as xr
+
+# Open a SAL signal by name and shot number
+ds = xr.open_dataset("sal://pulse/87737/ppf/signal/jetppf/magn/ipla", engine="sal")
+
+# Access the data
+data = ds["data"]
+status = ds["status"]
+
+# The dataset includes time coordinates
+time = ds["time"]
+
+# Access metadata
+units = ds["data"].attrs["units"]
+signal_name = ds["data"].attrs["sal_name"]
+```
+
+The URI format is: `sal://pulse/<shot_number>/<signal_name>`
+
+## Data Structure
+
+When you open a SAL dataset, sal-xarray creates an xarray Dataset with:
+- **data**: The signal data as a DataArray
+- **status**: The status data as a DataArray
+- **time**: Time coordinates (dimension)
+- **attrs**: Metadata including units and SAL signal name
+
+## Development
+
+### Setup
+
+Clone the repository and install development dependencies:
+
+```bash
+git clone https://github.com/samueljackson92/sal-xarray.git
+cd sal-xarray
+uv sync
+```
+
+### Running Tests
+
+```bash
+uv run pytest tests/
+```
+
+### Code Quality
+
+The project uses ruff for linting and formatting, and pylint for additional checks:
+
+```bash
+# Run ruff
+uv run ruff check sal_xarray tests
+uv run ruff format sal_xarray tests
+
+# Run pylint
+uv run pylint sal_xarray
+
+# Run ty
+uv run ty check sal_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

sal_xarray-0.1.0/README.md

@@ -0,0 +1,103 @@
+# sal-xarray
+
+An xarray backend for SAL (Simple Access Layer) that enables seamless integration of SAL data sources with the xarray ecosystem.
+
+## Overview
+
+sal-xarray provides a backend plugin for xarray that allows you to access SAL data sources using xarray's familiar API. It automatically handles the conversion of SAL signals to xarray DataArrays and Datasets, making it easy to work with SAL data in scientific Python workflows.
+## Features
+
+- **xarray Integration**: Access SAL data using xarray's `open_dataset` function
+- **Automatic Conversion**: Converts SAL signals to xarray DataArrays with proper coordinates and metadata
+- **Status Mask Handling**: Includes status mask data alongside signal data
+- **URI-based Access**: Simple URI scheme (`sal://pulse/<shot_number>/<signal_name>`) for accessing data
+
+## Installation 
+
+```bash
+pip install sal-xarray
+```
+
+Or using `uv`:
+
+```bash
+uv pip install sal-xarray
+```
+
+## Usage
+
+Open a SAL dataset using xarray:
+
+```python
+import xarray as xr
+
+# Open a SAL signal by name and shot number
+ds = xr.open_dataset("sal://pulse/87737/ppf/signal/jetppf/magn/ipla", engine="sal")
+
+# Access the data
+data = ds["data"]
+status = ds["status"]
+
+# The dataset includes time coordinates
+time = ds["time"]
+
+# Access metadata
+units = ds["data"].attrs["units"]
+signal_name = ds["data"].attrs["sal_name"]
+```
+
+The URI format is: `sal://pulse/<shot_number>/<signal_name>`
+
+## Data Structure
+
+When you open a SAL dataset, sal-xarray creates an xarray Dataset with:
+- **data**: The signal data as a DataArray
+- **status**: The status data as a DataArray
+- **time**: Time coordinates (dimension)
+- **attrs**: Metadata including units and SAL signal name
+
+## Development
+
+### Setup
+
+Clone the repository and install development dependencies:
+
+```bash
+git clone https://github.com/samueljackson92/sal-xarray.git
+cd sal-xarray
+uv sync
+```
+
+### Running Tests
+
+```bash
+uv run pytest tests/
+```
+
+### Code Quality
+
+The project uses ruff for linting and formatting, and pylint for additional checks:
+
+```bash
+# Run ruff
+uv run ruff check sal_xarray tests
+uv run ruff format sal_xarray tests
+
+# Run pylint
+uv run pylint sal_xarray
+
+# Run ty
+uv run ty check sal_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

sal_xarray-0.1.0/pyproject.toml

@@ -0,0 +1,71 @@
+[project]
+name = "sal-xarray"
+version = "0.1.0"
+description = "SAL 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 = [
+    "numpy<2",
+    "sal>=1.2.5",
+    "xarray>=2025.12.0",
+]
+
+[tool.setuptools]
+packages = ["sal_xarray"]
+
+[project.urls]
+repository = "https://github.com/samueljackson92/sal-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",
+    "ty>=0.0.12",
+]
+
+[project.entry-points."xarray.backends"]
+sal = "sal_xarray.main:SALBackendEntrypoint"
+
+[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}"'

sal_xarray-0.1.0/sal_xarray/main.py

@@ -0,0 +1,116 @@
+"""Xarray SAL backend entrypoint."""
+
+import os
+import re
+from typing import Any, Iterable
+
+import numpy as np
+import xarray as xr
+from sal.client import SALClient
+
+from xarray.backends import BackendEntrypoint
+from xarray.backends.common import ReadBuffer
+from xarray.backends.common import AbstractDataStore
+
+
+class SALBackendEntrypoint(BackendEntrypoint):
+    """Xarray SAL backend entrypoint."""
+
+    def open_dataset(
+        self,
+        filename_or_obj: str
+        | os.PathLike[Any]
+        | ReadBuffer
+        | bytes
+        | memoryview
+        | AbstractDataStore,
+        *,
+        drop_variables: str | Iterable[str] | None = None,
+        host: str = "https://sal.jetdata.eu",
+    ) -> xr.Dataset:
+        """Open a SAL dataset given a signal name and shot number.
+
+        Parameters
+        ----------
+        filename_or_obj : str
+            SAL dataset specified as sal://pulse/<shot_number>/<signal_name>
+        drop_variables : str or list of str, optional
+            Variables to drop from the dataset (not used).
+        """
+
+        if not isinstance(filename_or_obj, str):
+            raise ValueError("SAL backend only supports string filenames.")
+
+        if "sal://" not in filename_or_obj:
+            raise ValueError("SAL dataset must start with the sal:// scheme")
+
+        name = filename_or_obj.replace("sal://", "")
+        match = re.search(r"sal://pulse/(\d+)/", filename_or_obj)
+
+        if not match:
+            raise ValueError(
+                "Invalid SAL URL format. Expected sal://pulse/<shot_number>/<signal_name>"
+            )
+
+        shot = int(match.group(1))
+        name = "/" + name
+
+        client = SALClient(host=host)
+        try:
+            signal = client.get(name)
+        except Exception as e:
+            raise RuntimeError(f"Failed to retrieve SAL signal '{name}': {e}") from e
+
+        data = self.parse_data(signal)
+        data.attrs["shot_id"] = shot
+
+        status = xr.DataArray(signal.mask.status, dims=data.dims, coords=data.coords)
+        status.attrs["description"] = signal.mask.description
+        status.attrs["flag_values"] = np.unique(signal.mask.status)
+        status.attrs["flag_meanings"] = signal.mask.key.tolist()
+
+        dataset = data.to_dataset(name="data")
+        dataset["status"] = status
+        return dataset
+
+    def parse_data(self, signal) -> xr.DataArray:
+        """Parse a SAL LeafReport into an xarray DataArray."""
+
+        dims = {}
+        for index, item in enumerate(signal.dimensions):
+            name = f"dim_{index}"
+            if item.temporal:
+                name = "time"
+            dim = xr.DataArray(item.data, dims=[name], name=name)
+            dim.attrs["description"] = item.description
+            dim.attrs["units"] = item.units
+
+            dims[dim.name] = dim
+
+        data = xr.DataArray(
+            signal.data,
+            dims=[d.name for d in dims.values()],
+            coords={d.name: d for d in dims.values()},
+        )
+
+        data.attrs["description"] = signal.description
+        data.attrs["units"] = signal.units
+        data.attrs["sal_name"] = name
+
+        return data
+
+    def open_datatree(self, filename_or_obj, *, drop_variables=None):
+        self.open_dataset(filename_or_obj, drop_variables=drop_variables)
+
+    def open_groups_as_dict(self, filename_or_obj, **kwargs):
+        """Open groups as a dictionary (not supported for SAL backend)."""
+        raise NotImplementedError("SAL backend does not support opening groups")
+
+    open_dataset_parameters = ["filename_or_obj", "drop_variables"]
+
+    def guess_can_open(self, filename_or_obj):
+        return filename_or_obj.startswith("sal://")
+
+    description = "Use SAL data in Xarray"
+
+    url = "https://github.com/samueljackson92/sal-xarray"

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

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: sal-xarray
+Version: 0.1.0
+Summary: SAL 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/sal-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: numpy<2
+Requires-Dist: sal>=1.2.5
+Requires-Dist: xarray>=2025.12.0
+Dynamic: license-file
+
+# sal-xarray
+
+An xarray backend for SAL (Simple Access Layer) that enables seamless integration of SAL data sources with the xarray ecosystem.
+
+## Overview
+
+sal-xarray provides a backend plugin for xarray that allows you to access SAL data sources using xarray's familiar API. It automatically handles the conversion of SAL signals to xarray DataArrays and Datasets, making it easy to work with SAL data in scientific Python workflows.
+## Features
+
+- **xarray Integration**: Access SAL data using xarray's `open_dataset` function
+- **Automatic Conversion**: Converts SAL signals to xarray DataArrays with proper coordinates and metadata
+- **Status Mask Handling**: Includes status mask data alongside signal data
+- **URI-based Access**: Simple URI scheme (`sal://pulse/<shot_number>/<signal_name>`) for accessing data
+
+## Installation 
+
+```bash
+pip install sal-xarray
+```
+
+Or using `uv`:
+
+```bash
+uv pip install sal-xarray
+```
+
+## Usage
+
+Open a SAL dataset using xarray:
+
+```python
+import xarray as xr
+
+# Open a SAL signal by name and shot number
+ds = xr.open_dataset("sal://pulse/87737/ppf/signal/jetppf/magn/ipla", engine="sal")
+
+# Access the data
+data = ds["data"]
+status = ds["status"]
+
+# The dataset includes time coordinates
+time = ds["time"]
+
+# Access metadata
+units = ds["data"].attrs["units"]
+signal_name = ds["data"].attrs["sal_name"]
+```
+
+The URI format is: `sal://pulse/<shot_number>/<signal_name>`
+
+## Data Structure
+
+When you open a SAL dataset, sal-xarray creates an xarray Dataset with:
+- **data**: The signal data as a DataArray
+- **status**: The status data as a DataArray
+- **time**: Time coordinates (dimension)
+- **attrs**: Metadata including units and SAL signal name
+
+## Development
+
+### Setup
+
+Clone the repository and install development dependencies:
+
+```bash
+git clone https://github.com/samueljackson92/sal-xarray.git
+cd sal-xarray
+uv sync
+```
+
+### Running Tests
+
+```bash
+uv run pytest tests/
+```
+
+### Code Quality
+
+The project uses ruff for linting and formatting, and pylint for additional checks:
+
+```bash
+# Run ruff
+uv run ruff check sal_xarray tests
+uv run ruff format sal_xarray tests
+
+# Run pylint
+uv run pylint sal_xarray
+
+# Run ty
+uv run ty check sal_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

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[xarray.backends]
+sal = sal_xarray.main:SALBackendEntrypoint

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

@@ -0,0 +1,3 @@
+numpy<2
+sal>=1.2.5
+xarray>=2025.12.0

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

@@ -0,0 +1 @@
+sal_xarray

sal_xarray-0.1.0/setup.cfg

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

sal_xarray-0.1.0/tests/test_backend.py

@@ -0,0 +1,196 @@
+"""Tests for SAL xarray backend."""
+
+from unittest.mock import Mock, patch
+
+import numpy as np
+import pytest
+import xarray as xr
+
+from sal_xarray.main import SALBackendEntrypoint
+
+
+@pytest.fixture
+def mock_signal():
+    """Create a mock SAL signal object."""
+    signal = Mock()
+
+    # Mock dimension
+    dim = Mock()
+    dim.data = np.array([0.0, 1.0, 2.0, 3.0, 4.0])
+    dim.temporal = True
+    dim.description = "Time dimension"
+    dim.units = "s"
+
+    signal.dimensions = [dim]
+    signal.data = np.array([10.0, 20.0, 30.0, 40.0, 50.0])
+    signal.description = "Test signal"
+    signal.units = "V"
+
+    # Mock mask
+    mask = Mock()
+    mask.status = np.array([0, 0, 1, 0, 0])
+    mask.description = "Data quality mask"
+    mask.key = np.array(["good", "bad"])
+    signal.mask = mask
+
+    return signal
+
+
+@pytest.fixture
+def mock_sal_client(mock_signal):
+    """Create a mock SAL client."""
+    with patch("sal_xarray.main.SALClient") as MockClient:
+        client_instance = Mock()
+        client_instance.get.return_value = mock_signal
+        MockClient.return_value = client_instance
+        yield MockClient
+
+
+class TestSALBackendEntrypoint:
+    """Tests for SALBackendEntrypoint."""
+
+    def test_guess_can_open_valid(self):
+        """Test that guess_can_open returns True for sal:// URLs."""
+        backend = SALBackendEntrypoint()
+        assert backend.guess_can_open("sal://pulse/12345/signal_name")
+
+    def test_guess_can_open_invalid(self):
+        """Test that guess_can_open returns False for non-sal URLs."""
+        backend = SALBackendEntrypoint()
+        assert not backend.guess_can_open("http://example.com")
+        assert not backend.guess_can_open("file://data.nc")
+
+    def test_open_dataset_invalid_type(self):
+        """Test that open_dataset raises error for non-string input."""
+        backend = SALBackendEntrypoint()
+        with pytest.raises(
+            ValueError, match="SAL backend only supports string filenames"
+        ):
+            backend.open_dataset(123)
+
+    def test_open_dataset_missing_scheme(self):
+        """Test that open_dataset raises error when sal:// scheme is missing."""
+        backend = SALBackendEntrypoint()
+        with pytest.raises(
+            ValueError, match="SAL dataset must start with the sal:// scheme"
+        ):
+            backend.open_dataset("pulse/12345/signal_name")
+
+    def test_open_dataset_invalid_format(self):
+        """Test that open_dataset raises error for invalid URL format."""
+        backend = SALBackendEntrypoint()
+        with pytest.raises(ValueError, match="Invalid SAL URL format"):
+            backend.open_dataset("sal://invalid/format")
+
+    def test_open_dataset_success(self, mock_sal_client, mock_signal):
+        """Test successful dataset opening with mocked SAL client."""
+        backend = SALBackendEntrypoint()
+        ds = backend.open_dataset("sal://pulse/12345/signal_name")
+
+        # Check that dataset was created
+        assert isinstance(ds, xr.Dataset)
+
+        # Check that data variable exists
+        assert "data" in ds.data_vars
+        assert "status" in ds.data_vars
+
+        # Check dimensions
+        assert "time" in ds.dims
+        assert ds.sizes["time"] == 5
+
+        # Check data values
+        np.testing.assert_array_equal(ds["data"].values, mock_signal.data)
+
+        # Check attributes
+        assert ds["data"].attrs["description"] == "Test signal"
+        assert ds["data"].attrs["units"] == "V"
+        assert ds["data"].attrs["shot_id"] == 12345
+
+        # Check status variable
+        np.testing.assert_array_equal(ds["status"].values, mock_signal.mask.status)
+        assert ds["status"].attrs["description"] == "Data quality mask"
+
+        # Check that SALClient was called correctly
+        mock_sal_client.assert_called_once_with(host="https://sal.jetdata.eu")
+        mock_sal_client.return_value.get.assert_called_once()
+
+    def test_open_dataset_custom_host(self, mock_sal_client):
+        """Test opening dataset with custom host."""
+        backend = SALBackendEntrypoint()
+        custom_host = "https://custom.sal.server"
+        backend.open_dataset("sal://pulse/12345/signal_name", host=custom_host)
+
+        mock_sal_client.assert_called_once_with(host=custom_host)
+
+    def test_open_dataset_with_multiple_dimensions(self, mock_sal_client):
+        """Test opening dataset with multiple dimensions."""
+        # Create mock signal with two dimensions
+        signal = Mock()
+
+        dim0 = Mock()
+        dim0.data = np.array([0.0, 1.0, 2.0])
+        dim0.temporal = False
+        dim0.description = "Spatial dimension"
+        dim0.units = "m"
+
+        dim1 = Mock()
+        dim1.data = np.array([0.0, 1.0, 2.0, 3.0])
+        dim1.temporal = True
+        dim1.description = "Time dimension"
+        dim1.units = "s"
+
+        signal.dimensions = [dim0, dim1]
+        signal.data = np.random.rand(3, 4)
+        signal.description = "2D signal"
+        signal.units = "A"
+
+        mask = Mock()
+        mask.status = np.zeros((3, 4), dtype=int)
+        mask.description = "Mask"
+        mask.key = np.array(["good", "bad"])
+        signal.mask = mask
+
+        mock_sal_client.return_value.get.return_value = signal
+
+        backend = SALBackendEntrypoint()
+        ds = backend.open_dataset("sal://pulse/12345/signal_name")
+
+        # Check dimensions
+        assert "dim_0" in ds.dims
+        assert "time" in ds.dims
+        assert ds.sizes["dim_0"] == 3
+        assert ds.sizes["time"] == 4
+
+        # Check data shape
+        assert ds["data"].shape == (3, 4)
+
+    def test_open_dataset_client_error(self, mock_sal_client):
+        """Test that open_dataset handles SAL client errors."""
+        mock_sal_client.return_value.get.side_effect = Exception("Connection failed")
+
+        backend = SALBackendEntrypoint()
+        with pytest.raises(RuntimeError, match="Failed to retrieve SAL signal"):
+            backend.open_dataset("sal://pulse/12345/signal_name")
+
+    def test_open_dataset_different_shot_numbers(self, mock_sal_client):
+        """Test opening datasets with different shot numbers."""
+        backend = SALBackendEntrypoint()
+
+        # Test with different shot numbers
+        for shot_num in [1, 100, 99999]:
+            ds = backend.open_dataset(f"sal://pulse/{shot_num}/signal_name")
+            assert ds["data"].attrs["shot_id"] == shot_num
+
+
+class TestXarrayIntegration:
+    """Test integration with xarray's open_dataset function."""
+
+    def test_xr_open_dataset_with_engine(self, mock_sal_client):
+        """Test using xr.open_dataset with engine='sal'."""
+        # This test requires the backend to be registered
+        # In practice, this happens via entry_points in pyproject.toml
+        ds = xr.open_dataset("sal://pulse/12345/signal_name", engine="sal")
+
+        assert isinstance(ds, xr.Dataset)
+        assert "data" in ds.data_vars
+        assert "status" in ds.data_vars