datalab-platform 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

datalab/tests/features/control/call_method_unit_test.py

@@ -0,0 +1,104 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Test for call_method generic proxy feature
+"""
+
+# guitest: show
+
+from __future__ import annotations
+
+import xmlrpc.client
+
+import numpy as np
+from sigima.tests.data import get_test_image, get_test_signal
+
+from datalab.tests import datalab_in_background_context
+
+
+def test_call_method() -> None:
+    """Test call_method generic proxy feature"""
+    with datalab_in_background_context() as proxy:
+        # Test 1: Add some test data
+        signal = get_test_signal("paracetamol.txt")
+        proxy.add_object(signal)
+        image = get_test_image("flower.npy")
+        proxy.add_object(image)
+
+        # Test 2: Call remove_object without panel parameter (auto-detection)
+        # Should find method on current panel (signal panel)
+        proxy.set_current_panel("signal")
+        titles_before = proxy.get_object_titles("signal")
+        assert len(titles_before) == 1, "Should have one signal"
+
+        # Remove the signal object using call_method (no panel parameter)
+        # This should auto-detect and use the current panel
+        proxy.call_method("remove_object", force=True)
+
+        titles_after = proxy.get_object_titles("signal")
+        assert len(titles_after) == 0, "Signal should be removed"
+
+        # Test 3: Call method on specific panel
+        proxy.set_current_panel("image")
+        titles_before = proxy.get_object_titles("image")
+        assert len(titles_before) == 1, "Should have one image"
+
+        # Remove the image object using call_method with explicit panel parameter
+        # This tests the panel parameter is correctly passed through XML-RPC
+        proxy.call_method("remove_object", force=True, panel="image")
+
+        titles_after = proxy.get_object_titles("image")
+        assert len(titles_after) == 0, "Image should be removed"
+
+        # Test 3b: Verify panel parameter works when calling from different panel
+        x = np.linspace(0, 10, 100)
+        y = np.sin(x)
+        proxy.add_signal("Test Signal X", x, y)
+        proxy.set_current_panel("signal")
+        assert len(proxy.get_object_titles("signal")) == 1
+        # Call remove_object on signal panel while being on signal panel
+        proxy.call_method("remove_object", force=True, panel="signal")
+        assert len(proxy.get_object_titles("signal")) == 0
+
+        # Test 4: Test method resolution order (main window -> current panel)
+        # First verify we can call a main window method
+        current_panel = proxy.call_method("get_current_panel")
+        assert current_panel in ["signal", "image"], "Should return valid panel name"
+
+        # Test 5: Add more test data and test other methods
+        x = np.linspace(0, 10, 100)
+        y = np.sin(x)
+        proxy.add_signal("Test Signal 1", x, y)
+        proxy.add_signal("Test Signal 2", x, y * 2)
+
+        # Test calling a method with positional and keyword arguments
+        proxy.set_current_panel("signal")
+        proxy.select_objects([1, 2])
+
+        # Test delete_metadata through call_method
+        proxy.call_method("delete_metadata", refresh_plot=False, keep_roi=True)
+
+        # Test 5: Error handling - try to call a private method
+        # Note: XML-RPC converts exceptions to xmlrpc.client.Fault
+        try:
+            proxy.call_method("__init__")
+            assert False, "Should not allow calling private methods"
+        except xmlrpc.client.Fault as exc:
+            assert "private method" in exc.faultString.lower()
+
+        # Test 6: Error handling - try to call non-existent method
+        try:
+            proxy.call_method("this_method_does_not_exist")
+            assert False, "Should raise AttributeError for non-existent method"
+        except xmlrpc.client.Fault as exc:
+            assert "does not exist" in exc.faultString.lower()
+
+        # Test 7: Call main window method (not panel method)
+        panel_name = proxy.call_method("get_current_panel")
+        assert panel_name == "signal", "Should return current panel name"
+
+        print("✅ All call_method tests passed!")
+
+
+if __name__ == "__main__":
+    test_call_method()

datalab/tests/features/control/embedded1_unit_test.py

@@ -164,6 +164,14 @@ class AbstractClientWindow(QW.QMainWindow, metaclass=AbstractClientWindowMeta):
                 obj = func(title=self.sigtitle)
                 self.add_object(obj)
                 self.host.log(f"Added signal: {obj.title}")
+            # Remove last added signal to test remove_object
+            nobj0 = len(self.datalab.get_object_titles())
+            sig = self.datalab.get_object()  # Get the last added signal
+            self.datalab.remove_object(force=True)  # Test remove object method
+            assert len(self.datalab.get_object_titles()) == nobj0 - 1, (
+                "One object should have been removed"
+            )
+            self.add_object(sig)  # Add it back
 
     def add_images(self):
         """Add images to DataLab"""

datalab/tests/features/control/remoteclient_app_test.py

@@ -20,7 +20,7 @@ from qtpy import QtWidgets as QW
 from datalab.config import _
 from datalab.control.proxy import RemoteProxy
 from datalab.env import execenv
-from datalab.tests import run_datalab_in_background
+from datalab.tests import close_datalab_background, run_datalab_in_background
 from datalab.tests.features.control import embedded1_unit_test
 from datalab.tests.features.control.remoteclient_unit import multiple_commands
 from datalab.utils.qthelpers import bring_to_front
@@ -179,40 +179,44 @@ def qt_wait_print(dt: float, message: str, parent=None):
 def test_remote_client():
     """Remote client application test"""
     run_datalab_in_background()
-
-    with qt_app_context(exec_loop=True):
-        window = HostWindow()
-        window.resize(800, 800)
-        window.show()
-        dt = 1
-        if execenv.unattended:
-            qt_wait(8, show_message=True, parent=window)
-            window.init_cdl()
-            with qt_wait_print(dt, "Executing multiple commands"):
-                window.exec_multiple_cmd()
-            bring_to_front(window)
-            with qt_wait_print(dt, "Raising DataLab window"):
-                window.raise_cdl()
-            with qt_wait_print(dt, "Import macro"):
-                window.import_macro()
-            with qt_wait_print(dt, "Getting object titles"):
-                window.get_object_titles()
-            with qt_wait_print(dt, "Getting object uuids"):
-                window.get_object_uuids()
-            with qt_wait_print(dt, "Getting object"):
-                window.get_object()
-            with qt_wait_print(dt, "Adding signals"):
-                window.add_signals()
-            with qt_wait_print(dt, "Adding images"):
-                window.add_images()
-            with qt_wait_print(dt, "Run macro"):
-                window.run_macro()
-            with qt_wait_print(dt * 2, "Stop macro"):
-                window.stop_macro()
-            with qt_wait_print(dt, "Removing all objects"):
-                window.remove_all()
-            with qt_wait_print(dt, "Closing DataLab"):
-                window.close_datalab()
+    try:
+        with qt_app_context(exec_loop=True):
+            window = HostWindow()
+            window.resize(800, 800)
+            window.show()
+            dt = 1
+            if execenv.unattended:
+                qt_wait(8, show_message=True, parent=window)
+                window.init_cdl()
+                with qt_wait_print(dt, "Executing multiple commands"):
+                    window.exec_multiple_cmd()
+                bring_to_front(window)
+                with qt_wait_print(dt, "Raising DataLab window"):
+                    window.raise_cdl()
+                with qt_wait_print(dt, "Import macro"):
+                    window.import_macro()
+                with qt_wait_print(dt, "Getting object titles"):
+                    window.get_object_titles()
+                with qt_wait_print(dt, "Getting object uuids"):
+                    window.get_object_uuids()
+                with qt_wait_print(dt, "Getting object"):
+                    window.get_object()
+                with qt_wait_print(dt, "Adding signals"):
+                    window.add_signals()
+                with qt_wait_print(dt, "Adding images"):
+                    window.add_images()
+                with qt_wait_print(dt, "Run macro"):
+                    window.run_macro()
+                with qt_wait_print(dt * 2, "Stop macro"):
+                    window.stop_macro()
+                with qt_wait_print(dt, "Removing all objects"):
+                    window.remove_all()
+                with qt_wait_print(dt, "Closing DataLab"):
+                    window.close_datalab()
+    except Exception as exc:
+        execenv.print("❌ Remote client test failed.")
+        close_datalab_background()  # Ensure DataLab is closed in case of failure
+        raise exc
 
 
 if __name__ == "__main__":

datalab/tests/features/control/simpleclient_unit_test.py

@@ -159,7 +159,7 @@ def test_with_real_server() -> None:
 
     # Launch DataLab application in the background
     execenv.print("Launching DataLab in background...")
-    run_datalab_in_background(wait_until_ready=True)
+    run_datalab_in_background()
 
     # Import and run the comprehensive test from sigima
     execenv.print("Running comprehensive client tests with real server...")
@@ -176,9 +176,13 @@ def test_with_real_server() -> None:
         # Run all tests
         tester.run_comprehensive_test()
         execenv.print("✨ All tests passed with real DataLab server!")
-    finally:
-        # Clean up
+    except Exception as exc:
+        execenv.print("❌ Some tests failed with real DataLab server.")
         tester.close_datalab()
+        raise exc
+
+    # Clean up
+    tester.close_datalab()
 
 
 def test_version_compatibility() -> None:

datalab/tests/features/hdf5/h5browser2_unit.py

@@ -15,7 +15,7 @@ import time
 import numpy as np
 import psutil
 from guidata.qthelpers import qt_app_context
-from sigima.tests.vistools import view_curves
+from sigima.viz import view_curves
 
 from datalab.env import execenv
 from datalab.tests import helpers

datalab/tests/features/image/background_dialog_test.py

@@ -15,7 +15,7 @@ import sigima.objects
 import sigima.params
 import sigima.proc.image as sipi
 from guidata.qthelpers import exec_dialog, qt_app_context
-from sigima.tests import vistools
+from sigima import viz
 from sigima.tests.data import create_noisy_gaussian_image
 
 from datalab.env import execenv
@@ -58,7 +58,7 @@ def test_image_offset_correction_with_background_dialog() -> None:
             param.x0, param.y0, param.dx, param.dy = ix0, iy0, ix1 - ix0, iy1 - iy0
             i2 = sipi.offset_correction(i1, param)
             i3 = sipi.clip(i2, sigima.params.ClipParam.create(lower=0))
-            vistools.view_images_side_by_side(
+            viz.view_images_side_by_side(
                 [i1, i3],
                 titles=["Original image", "Corrected image"],
                 title="Image offset correction and thresholding",

datalab/tests/features/image/imagetools_unit_test.py

@@ -12,7 +12,7 @@ Simple image dialog for testing all image tools available in DataLab
 from guidata.qthelpers import qt_app_context
 from plotpy.builder import make
 from sigima.tests.data import create_noisy_gaussian_image
-from sigima.tests.vistools import view_image_items
+from sigima.viz import view_image_items
 
 
 def test_image_tools_unit():

datalab/tests/features/signal/baseline_dialog_test.py

@@ -15,7 +15,7 @@ import sigima.objects
 import sigima.proc.signal as sips
 from guidata.qthelpers import exec_dialog, qt_app_context
 from sigima.tests.data import create_paracetamol_signal
-from sigima.tests.vistools import view_curves
+from sigima.viz import view_curves
 
 from datalab.env import execenv
 from datalab.widgets.signalbaseline import SignalBaselineDialog

datalab/tests/webapi_test.py

@@ -0,0 +1,395 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause License
+# See LICENSE file for details
+
+"""
+Web API Tests
+=============
+
+Unit and integration tests for the DataLab Web API.
+"""
+
+from __future__ import annotations
+
+import io
+import zipfile
+
+import numpy as np
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+from sigima import ImageObj, SignalObj
+
+from datalab.webapi.routes import (
+    generate_auth_token,
+    router,
+    set_adapter,
+    set_auth_token,
+    set_server_url,
+)
+from datalab.webapi.schema import (
+    MetadataPatchRequest,
+    ObjectListResponse,
+    ObjectMetadata,
+    ObjectType,
+)
+from datalab.webapi.serialization import (
+    deserialize_object_from_npz,
+    object_to_metadata,
+    serialize_object_to_npz,
+)
+
+
+class TestNPZSerialization:
+    """Tests for NPZ serialization module."""
+
+    def test_signal_round_trip(self):
+        """Test serializing and deserializing a SignalObj."""
+        # Create a signal
+        x = np.linspace(0, 10, 100)
+        y = np.sin(x)
+        obj = SignalObj()
+        obj.set_xydata(x, y)
+        obj.title = "Test Signal"
+        obj.xlabel = "Time"
+        obj.ylabel = "Amplitude"
+        obj.xunit = "s"
+        obj.yunit = "V"
+
+        # Serialize
+        data = serialize_object_to_npz(obj)
+        assert isinstance(data, bytes)
+        assert len(data) > 0
+
+        # Verify it's a valid zip
+        buffer = io.BytesIO(data)
+        with zipfile.ZipFile(buffer, "r") as zf:
+            assert "x.npy" in zf.namelist()
+            assert "y.npy" in zf.namelist()
+            assert "metadata.json" in zf.namelist()
+
+        # Deserialize
+        result = deserialize_object_from_npz(data)
+
+        # Verify
+        assert type(result).__name__ == "SignalObj"
+        np.testing.assert_array_equal(result.x, x)
+        np.testing.assert_array_equal(result.y, y)
+        assert result.title == "Test Signal"
+        assert result.xlabel == "Time"
+        assert result.ylabel == "Amplitude"
+        assert result.xunit == "s"
+        assert result.yunit == "V"
+
+    def test_signal_with_uncertainties(self):
+        """Test signal with dx/dy uncertainties."""
+        x = np.linspace(0, 10, 50)
+        y = np.cos(x)
+        dx = np.ones_like(x) * 0.01
+        dy = np.abs(y) * 0.05
+
+        obj = SignalObj()
+        obj.set_xydata(x, y, dx=dx, dy=dy)
+        obj.title = "Signal with Errors"
+
+        data = serialize_object_to_npz(obj)
+        result = deserialize_object_from_npz(data)
+
+        np.testing.assert_array_equal(result.dx, dx)
+        np.testing.assert_array_equal(result.dy, dy)
+
+    def test_image_round_trip(self):
+        """Test serializing and deserializing an ImageObj."""
+        # Create an image
+        data = np.random.rand(128, 128).astype(np.float32)
+        obj = ImageObj()
+        obj.data = data
+        obj.title = "Test Image"
+        obj.xlabel = "X"
+        obj.ylabel = "Y"
+        obj.zlabel = "Intensity"
+        obj.x0 = 10.0
+        obj.y0 = 20.0
+        obj.dx = 0.5
+        obj.dy = 0.5
+
+        # Serialize
+        npz_data = serialize_object_to_npz(obj)
+        assert isinstance(npz_data, bytes)
+
+        # Verify structure
+        buffer = io.BytesIO(npz_data)
+        with zipfile.ZipFile(buffer, "r") as zf:
+            assert "data.npy" in zf.namelist()
+            assert "metadata.json" in zf.namelist()
+
+        # Deserialize
+        result = deserialize_object_from_npz(npz_data)
+
+        # Verify
+        assert type(result).__name__ == "ImageObj"
+        np.testing.assert_array_equal(result.data, data)
+        assert result.title == "Test Image"
+        assert result.x0 == 10.0
+        assert result.y0 == 20.0
+        assert result.dx == 0.5
+        assert result.dy == 0.5
+
+    def test_image_preserves_dtype(self):
+        """Test that image dtype is preserved through serialization."""
+        for dtype in [np.uint8, np.uint16, np.float32, np.float64]:
+            obj = ImageObj()
+            obj.data = np.random.randint(0, 255, (64, 64)).astype(dtype)
+            obj.title = f"Image {dtype.__name__}"
+
+            data = serialize_object_to_npz(obj)
+            result = deserialize_object_from_npz(data)
+
+            assert result.data.dtype == dtype, (
+                f"Expected {dtype}, got {result.data.dtype}"
+            )
+
+
+class TestObjectMetadata:
+    """Tests for object_to_metadata helper."""
+
+    def test_signal_metadata(self):
+        """Test extracting metadata from a SignalObj."""
+        obj = SignalObj()
+        obj.set_xydata(np.linspace(0, 10, 100), np.sin(np.linspace(0, 10, 100)))
+        obj.title = "My Signal"
+        obj.xlabel = "Time"
+
+        meta = object_to_metadata(obj, "my_signal")
+
+        assert meta["name"] == "my_signal"
+        assert meta["type"] == "signal"
+        assert meta["shape"] == [100]
+        assert meta["dtype"] == "float64"
+        assert meta["title"] == "My Signal"
+        assert meta["xlabel"] == "Time"
+
+    def test_image_metadata(self):
+        """Test extracting metadata from an ImageObj."""
+        obj = ImageObj()
+        obj.data = np.zeros((256, 512), dtype=np.uint16)
+        obj.title = "My Image"
+        obj.x0 = 5.0
+        obj.dx = 0.1
+
+        meta = object_to_metadata(obj, "my_image")
+
+        assert meta["name"] == "my_image"
+        assert meta["type"] == "image"
+        assert meta["shape"] == [256, 512]
+        assert meta["dtype"] == "uint16"
+        assert meta["title"] == "My Image"
+        assert meta["attributes"]["x0"] == 5.0
+        assert meta["attributes"]["dx"] == 0.1
+
+
+class TestSchemaModels:
+    """Tests for Pydantic schema models."""
+
+    def test_object_metadata_validation(self):
+        """Test ObjectMetadata model validation."""
+        # Valid metadata
+        meta = ObjectMetadata(
+            name="test",
+            type=ObjectType.SIGNAL,
+            shape=[100],
+            dtype="float64",
+        )
+        assert meta.name == "test"
+        assert meta.type == ObjectType.SIGNAL
+
+        # With optional fields
+        meta_full = ObjectMetadata(
+            name="test2",
+            type=ObjectType.IMAGE,
+            shape=[256, 256],
+            dtype="uint8",
+            title="Test Image",
+            xlabel="X",
+            ylabel="Y",
+            attributes={"custom": "value"},
+        )
+        assert meta_full.attributes == {"custom": "value"}
+
+    def test_object_list_response(self):
+        """Test ObjectListResponse model."""
+        objs = [
+            ObjectMetadata(
+                name="s1", type=ObjectType.SIGNAL, shape=[50], dtype="float64"
+            ),
+            ObjectMetadata(
+                name="i1", type=ObjectType.IMAGE, shape=[64, 64], dtype="uint8"
+            ),
+        ]
+        response = ObjectListResponse(objects=objs, count=2)
+
+        assert len(response.objects) == 2
+        assert response.count == 2
+
+    def test_metadata_patch_request(self):
+        """Test MetadataPatchRequest model."""
+        patch = MetadataPatchRequest(title="New Title", xlabel="Updated X")
+
+        # model_dump should exclude None values
+        data = patch.model_dump(exclude_none=True)
+        assert "title" in data
+        assert "xlabel" in data
+        assert "ylabel" not in data
+
+
+class TestAuthToken:
+    """Tests for authentication token handling."""
+
+    def test_generate_token(self):
+        """Test token generation."""
+        token1 = generate_auth_token()
+        token2 = generate_auth_token()
+
+        # Tokens should be non-empty strings
+        assert isinstance(token1, str)
+        assert len(token1) > 20
+
+        # Each token should be unique
+        assert token1 != token2
+
+
+# Integration tests would require a running DataLab instance
+# They are marked for opt-in execution
+
+
+class MockWorkspaceAdapter:
+    """Mock workspace adapter for testing."""
+
+    def __init__(self):
+        self._objects: dict[str, SignalObj | ImageObj] = {}
+
+    def add_object(self, name: str, obj: SignalObj | ImageObj) -> None:
+        """Add an object to the mock workspace."""
+        self._objects[name] = obj
+
+    def list_objects(self) -> list[tuple[str, str]]:
+        """List all objects in the mock workspace."""
+        result = []
+        for name, obj in self._objects.items():
+            panel = "signal" if type(obj).__name__ == "SignalObj" else "image"
+            result.append((name, panel))
+        return result
+
+    def get_object(self, name: str) -> SignalObj | ImageObj:
+        """Get an object by name."""
+        if name not in self._objects:
+            raise KeyError(f"Object '{name}' not found")
+        return self._objects[name]
+
+
+class TestAPIEndpointsWithMock:
+    """Integration tests using a mock workspace adapter."""
+
+    @pytest.fixture
+    def test_client(self):
+        """Create a test client with mock adapter."""
+        # Create a fresh app with the router
+        app = FastAPI()
+        app.include_router(router)
+
+        # Set up mock adapter and auth
+        mock_adapter = MockWorkspaceAdapter()
+        test_token = "test-token-12345"
+
+        set_adapter(mock_adapter)
+        set_auth_token(test_token)
+        set_server_url("http://localhost:8000")
+
+        client = TestClient(app)
+        return client, test_token, mock_adapter
+
+    def test_status_endpoint(self, test_client):
+        """Test the /api/v1/status endpoint (no auth required)."""
+        client, _token, _adapter = test_client
+
+        response = client.get("/api/v1/status")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["running"] is True
+        assert "version" in data
+        assert data["api_version"] == "v1"
+        assert data["url"] == "http://localhost:8000"
+        assert data["workspace_mode"] == "live"
+
+    def test_list_objects_requires_auth(self, test_client):
+        """Test that /api/v1/objects requires authentication."""
+        client, _token, _adapter = test_client
+
+        # Request without Authorization header should return 401
+        response = client.get("/api/v1/objects")
+
+        assert response.status_code == 401
+        assert "WWW-Authenticate" in response.headers
+        assert response.headers["WWW-Authenticate"] == "Bearer"
+
+    def test_list_objects_with_invalid_token(self, test_client):
+        """Test that /api/v1/objects rejects invalid tokens."""
+        client, _token, _adapter = test_client
+
+        response = client.get(
+            "/api/v1/objects", headers={"Authorization": "Bearer wrong-token"}
+        )
+
+        assert response.status_code == 401
+
+    def test_list_objects_with_valid_token(self, test_client):
+        """Test that /api/v1/objects works with valid token."""
+        client, token, adapter = test_client
+
+        # Add a test signal to the mock adapter
+        x = np.linspace(0, 10, 50)
+        y = np.sin(x)
+        signal = SignalObj()
+        signal.set_xydata(x, y)
+        signal.title = "Test Signal"
+        adapter.add_object("Test Signal", signal)
+
+        response = client.get(
+            "/api/v1/objects", headers={"Authorization": f"Bearer {token}"}
+        )
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["count"] == 1
+        assert len(data["objects"]) == 1
+        assert data["objects"][0]["name"] == "Test Signal"
+        assert data["objects"][0]["type"] == "signal"
+
+    def test_list_objects_empty_workspace(self, test_client):
+        """Test listing objects in an empty workspace."""
+        client, token, _adapter = test_client
+
+        response = client.get(
+            "/api/v1/objects", headers={"Authorization": f"Bearer {token}"}
+        )
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["count"] == 0
+        assert data["objects"] == []
+
+    def test_invalid_auth_header_format(self, test_client):
+        """Test that malformed Authorization headers are rejected."""
+        client, _token, _adapter = test_client
+
+        # Missing "Bearer" prefix
+        response = client.get(
+            "/api/v1/objects", headers={"Authorization": "test-token-12345"}
+        )
+        assert response.status_code == 401
+
+        # Wrong prefix
+        response = client.get(
+            "/api/v1/objects", headers={"Authorization": "Basic test-token-12345"}
+        )
+        assert response.status_code == 401