datalab-platform 0.0.1.dev0__py3-none-any.whl → 1.0.1__py3-none-any.whl

datalab/adapters_plotpy/annotations.py

@@ -0,0 +1,124 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Annotation Adapter for PlotPy Integration
+-----------------------------------------
+
+This module bridges Sigima's format-agnostic annotation storage with PlotPy's
+plot item system. It handles bidirectional conversion between:
+- Sigima: list[dict] (JSON-serializable)
+- PlotPy: list[AnnotatedShape] (plot items)
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from guidata.io import JSONReader, JSONWriter
+from plotpy.io import load_items, save_items
+
+if TYPE_CHECKING:
+    from plotpy.items import AnnotatedShape
+    from sigima.objects.base import BaseObj
+
+
+class PlotPyAnnotationAdapter:
+    """Adapter for converting between Sigima annotations and PlotPy items.
+
+    This class provides the bridge between Sigima's generic annotation storage
+    (list of dicts) and PlotPy's specific plot item format.
+
+    Example:
+        >>> from sigima.objects.signal.creation import create_signal
+        >>> obj = create_signal("Test")
+        >>> adapter = PlotPyAnnotationAdapter(obj)
+        >>>
+        >>> # Add PlotPy items
+        >>> from plotpy.items import AnnotatedRectangle
+        >>> rect = AnnotatedRectangle(0, 0, 10, 10)
+        >>> adapter.add_items([rect])
+        >>>
+        >>> # Retrieve as PlotPy items
+        >>> items = adapter.get_items()
+        >>> len(items)
+        1
+    """
+
+    def __init__(self, obj: BaseObj):
+        """Initialize adapter with an object.
+
+        Args:
+            obj: Signal or image object with annotation support
+        """
+        self.obj = obj
+
+    def get_items(self) -> list[AnnotatedShape]:
+        """Get annotations as PlotPy items.
+
+        Returns:
+            List of PlotPy annotation items
+
+        Notes:
+            This method deserializes the JSON data stored in the object using
+            PlotPy's load_items() function.
+        """
+        annotations = self.obj.get_annotations()
+        if not annotations:
+            return []
+
+        items = []
+        for ann_dict in annotations:
+            # Each annotation dict should contain PlotPy's JSON serialization
+            if "plotpy_json" in ann_dict:
+                try:
+                    json_str = ann_dict["plotpy_json"]
+                    for item in load_items(JSONReader(json_str)):
+                        items.append(item)
+                except (json.JSONDecodeError, ValueError, KeyError):
+                    # Skip invalid items
+                    continue
+
+        return items
+
+    def set_items(self, items: list[AnnotatedShape]) -> None:
+        """Set annotations from PlotPy items.
+
+        Args:
+            items: List of PlotPy annotation items
+
+        Notes:
+            This method serializes PlotPy items to JSON using PlotPy's
+            save_items() function and stores them in the Sigima format.
+        """
+        if not items:
+            self.obj.clear_annotations()
+            return
+
+        # Convert PlotPy items to our annotation format
+        annotations = []
+        for item in items:
+            writer = JSONWriter(None)
+            save_items(writer, [item])
+            ann_dict = {
+                "type": "plotpy_item",
+                "item_class": item.__class__.__name__,
+                "plotpy_json": writer.get_json(),
+            }
+            annotations.append(ann_dict)
+
+        self.obj.set_annotations(annotations)
+
+    def add_items(self, items: list[AnnotatedShape]) -> None:
+        """Add PlotPy items to existing annotations.
+
+        Args:
+            items: List of PlotPy annotation items to add
+        """
+        current_items = self.get_items()
+        current_items.extend(items)
+        self.set_items(current_items)
+
+    def clear(self) -> None:
+        """Clear all annotations."""
+        self.obj.clear_annotations()

datalab/adapters_plotpy/base.py

@@ -0,0 +1,110 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+PlotPy Adapter Base Module
+--------------------------
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from guidata.io import JSONReader, JSONWriter
+from plotpy.io import load_items, save_items
+from plotpy.items import (
+    AbstractLabelItem,
+    AnnotatedSegment,
+    AnnotatedShape,
+)
+
+if TYPE_CHECKING:
+    from plotpy.items import AbstractShape
+    from plotpy.styles import AnnotationParam
+
+
+def config_annotated_shape(
+    item: AnnotatedShape,
+    fmt: str,
+    lbl: bool,
+    section: str | None = None,
+    option: str | None = None,
+    show_computations: bool | None = None,
+):
+    """Configurate annotated shape
+
+    Args:
+        item: Annotated shape item
+        fmt: Format string
+        lbl: Show label
+        section: Shape style section (e.g. "plot")
+        option: Shape style option (e.g. "shape/drag")
+        show_computations: Show computations
+    """
+    param: AnnotationParam = item.annotationparam
+    param.format = fmt
+    param.show_label = lbl
+    if show_computations is not None:
+        param.show_computations = show_computations
+
+    if isinstance(item, AnnotatedSegment):
+        item.label.labelparam.anchor = "T"
+        item.label.labelparam.update_item(item.label)
+
+    param.update_item(item)
+    if section is not None and option is not None:
+        item.set_style(section, option)
+
+
+# TODO: [P3] Move this function as a method of plot items in PlotPy
+def set_plot_item_editable(
+    item: AbstractShape | AbstractLabelItem | AnnotatedShape, state
+):
+    """Set plot item editable state
+
+    Args:
+        item: Plot item
+        state: State
+    """
+    item.set_movable(state)
+    item.set_resizable(state and not isinstance(item, AbstractLabelItem))
+    item.set_rotatable(state and not isinstance(item, AbstractLabelItem))
+    item.set_readonly(not state)
+    item.set_selectable(state)
+
+
+def items_to_json(items: list) -> str | None:
+    """Convert plot items to JSON string
+
+    Args:
+        items: list of plot items
+
+    Returns:
+        JSON string or None if items is empty
+    """
+    if items:
+        writer = JSONWriter(None)
+        save_items(writer, items)
+        return writer.get_json(indent=4)
+    return None
+
+
+def json_to_items(json_str: str | None) -> list:
+    """Convert JSON string to plot items
+
+    Args:
+        json_str: JSON string or None
+
+    Returns:
+        List of plot items
+    """
+    items = []
+    if json_str:
+        try:
+            for item in load_items(JSONReader(json_str)):
+                items.append(item)
+        except json.decoder.JSONDecodeError:
+            pass
+    return items

datalab/adapters_plotpy/converters.py

@@ -0,0 +1,86 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+PlotPy Adapter Converters
+-------------------------
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from plotpy.items import (
+    AnnotatedCircle,
+    AnnotatedPolygon,
+    AnnotatedRectangle,
+    AnnotatedXRange,
+)
+from sigima.objects import (
+    CircularROI,
+    PolygonalROI,
+    RectangularROI,
+    SegmentROI,
+)
+
+from datalab.adapters_plotpy.factories import create_adapter_from_object
+from datalab.adapters_plotpy.roi.image import (
+    PolygonalROIPlotPyAdapter,
+    RectangularROIPlotPyAdapter,
+)
+
+if TYPE_CHECKING:
+    from sigima.objects import ImageObj, SignalObj
+
+
+def plotitem_to_singleroi(
+    plot_item: AnnotatedXRange
+    | AnnotatedRectangle
+    | AnnotatedCircle
+    | AnnotatedPolygon,
+) -> SegmentROI | RectangularROI | CircularROI | PolygonalROI:
+    """Create a single ROI from the given PlotPy item to integrate with DataLab
+
+    Args:
+        plot_item: The PlotPy item for which to create a single ROI
+
+    Returns:
+        A single ROI instance
+    """
+    # pylint: disable=import-outside-toplevel
+    from datalab.adapters_plotpy.roi.image import (
+        CircularROIPlotPyAdapter,
+    )
+    from datalab.adapters_plotpy.roi.signal import (
+        SegmentROIPlotPyAdapter,
+    )
+
+    if isinstance(plot_item, AnnotatedXRange):
+        adapter = SegmentROIPlotPyAdapter
+    elif isinstance(plot_item, AnnotatedRectangle):
+        adapter = RectangularROIPlotPyAdapter
+    elif isinstance(plot_item, AnnotatedCircle):
+        adapter = CircularROIPlotPyAdapter
+    elif isinstance(plot_item, AnnotatedPolygon):
+        adapter = PolygonalROIPlotPyAdapter
+    else:
+        raise TypeError(f"Unsupported PlotPy item type: {type(plot_item)}")
+    return adapter.from_plot_item(plot_item)
+
+
+def singleroi_to_plotitem(
+    roi: SegmentROI | RectangularROI | CircularROI | PolygonalROI,
+    obj: SignalObj | ImageObj,
+) -> AnnotatedXRange | AnnotatedRectangle | AnnotatedCircle | AnnotatedPolygon:
+    """Create a PlotPy item from the given single ROI to integrate with DataLab
+
+    Args:
+        roi: The single ROI for which to create a PlotPy item
+        obj: The object (signal or image) associated with the ROI
+
+    Returns:
+        A PlotPy item instance
+    """
+    adapter = create_adapter_from_object(roi)
+    return adapter.to_plot_item(obj)

datalab/adapters_plotpy/factories.py

@@ -0,0 +1,80 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+PlotPy Adapter Factories
+------------------------
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+
+def create_adapter_from_object(object_to_adapt):
+    """Create an adapter for the given object to integrate with PlotPy
+
+    Args:
+        object_to_adapt: The object to adapt (signal, image, ROI, or scalar result)
+
+    Returns:
+        An adapter instance
+    """
+    # pylint: disable=import-outside-toplevel
+    # Import adapters as needed to avoid circular imports
+    from sigima.objects import (
+        CircularROI,
+        ImageObj,
+        ImageROI,
+        PolygonalROI,
+        RectangularROI,
+        SegmentROI,
+        SignalObj,
+        SignalROI,
+    )
+
+    from datalab.adapters_metadata import GeometryAdapter, TableAdapter
+
+    if isinstance(object_to_adapt, GeometryAdapter):
+        from datalab.adapters_plotpy.objects.scalar import GeometryPlotPyAdapter
+
+        adapter = GeometryPlotPyAdapter(object_to_adapt)
+    elif isinstance(object_to_adapt, TableAdapter):
+        from datalab.adapters_plotpy.objects.scalar import TablePlotPyAdapter
+
+        adapter = TablePlotPyAdapter(object_to_adapt)
+
+    elif isinstance(object_to_adapt, SignalObj):
+        from datalab.adapters_plotpy.objects.signal import SignalObjPlotPyAdapter
+
+        adapter = SignalObjPlotPyAdapter(object_to_adapt)
+    elif isinstance(object_to_adapt, SignalROI):
+        from datalab.adapters_plotpy.roi.signal import SignalROIPlotPyAdapter
+
+        adapter = SignalROIPlotPyAdapter(object_to_adapt)
+    elif isinstance(object_to_adapt, SegmentROI):
+        from datalab.adapters_plotpy.roi.signal import SegmentROIPlotPyAdapter
+
+        adapter = SegmentROIPlotPyAdapter(object_to_adapt)
+    elif isinstance(object_to_adapt, ImageObj):
+        from datalab.adapters_plotpy.objects.image import ImageObjPlotPyAdapter
+
+        adapter = ImageObjPlotPyAdapter(object_to_adapt)
+    elif isinstance(object_to_adapt, RectangularROI):
+        from datalab.adapters_plotpy.roi.image import RectangularROIPlotPyAdapter
+
+        adapter = RectangularROIPlotPyAdapter(object_to_adapt)
+    elif isinstance(object_to_adapt, CircularROI):
+        from datalab.adapters_plotpy.roi.image import CircularROIPlotPyAdapter
+
+        adapter = CircularROIPlotPyAdapter(object_to_adapt)
+    elif isinstance(object_to_adapt, PolygonalROI):
+        from datalab.adapters_plotpy.roi.image import PolygonalROIPlotPyAdapter
+
+        adapter = PolygonalROIPlotPyAdapter(object_to_adapt)
+    elif isinstance(object_to_adapt, ImageROI):
+        from datalab.adapters_plotpy.roi.image import ImageROIPlotPyAdapter
+
+        adapter = ImageROIPlotPyAdapter(object_to_adapt)
+    else:
+        raise TypeError(f"Unsupported object type: {type(object_to_adapt)}")
+    return adapter

datalab/adapters_plotpy/objects/base.py

@@ -0,0 +1,197 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+PlotPy Adapter Base Object Module
+---------------------------------
+"""
+
+from __future__ import annotations
+
+import abc
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    TypeVar,
+)
+
+from guidata.dataset import update_dataset
+from plotpy.items import (
+    AnnotatedShape,
+)
+from sigima.objects.base import (
+    ROI_KEY,
+    TypeObj,
+)
+
+from datalab.adapters_metadata import GeometryAdapter
+from datalab.adapters_plotpy.annotations import PlotPyAnnotationAdapter
+from datalab.adapters_plotpy.base import (
+    config_annotated_shape,
+    set_plot_item_editable,
+)
+from datalab.adapters_plotpy.objects.scalar import GeometryPlotPyAdapter
+from datalab.config import Conf
+
+if TYPE_CHECKING:
+    from plotpy.items import CurveItem, MaskedXYImageItem
+
+TypePlotItem = TypeVar("TypePlotItem", bound="CurveItem | MaskedXYImageItem")
+
+
+class BaseObjPlotPyAdapter(Generic[TypeObj, TypePlotItem]):
+    """Object (signal/image) plot item adapter class"""
+
+    DEFAULT_FMT = "s"  # This is overriden in children classes
+    CONF_FMT = Conf.view.sig_format  # This is overriden in children classes
+
+    def __init__(self, obj: TypeObj) -> None:
+        """Initialize the adapter with the object.
+
+        Args:
+            obj: object (signal/image)
+        """
+        self.obj = obj
+        self.__default_options = {
+            "format": "%" + self.CONF_FMT.get(self.DEFAULT_FMT),
+            "showlabel": Conf.view.show_label.get(False),
+        }
+        self.annotation_adapter = PlotPyAnnotationAdapter(obj)
+
+    def get_obj_option(self, name: str) -> Any:
+        """Get object option value.
+        Args:
+            name: option name
+
+        Returns:
+            Option value
+        """
+        default = self.__default_options[name]
+        return self.obj.get_metadata_option(name, default)
+
+    @abc.abstractmethod
+    def make_item(self, update_from: TypePlotItem | None = None) -> TypePlotItem:
+        """Make plot item from data.
+
+        Args:
+            update_from: update
+
+        Returns:
+            Plot item
+        """
+
+    @abc.abstractmethod
+    def update_item(self, item: TypePlotItem, data_changed: bool = True) -> None:
+        """Update plot item from data.
+
+        Args:
+            item: plot item
+            data_changed: if True, data has changed
+        """
+
+    def add_annotations_from_items(self, items: list) -> None:
+        """Add object annotations (annotation plot items).
+
+        Args:
+            items: annotation plot items
+        """
+        # Use the new annotation adapter
+        self.annotation_adapter.add_items(items)
+
+    def set_annotations_from_items(self, items: list) -> None:
+        """Set object annotations (annotation plot items), replacing any existing ones.
+
+        Args:
+            items: annotation plot items
+        """
+        # Use the new annotation adapter
+        self.annotation_adapter.set_items(items)
+
+    @abc.abstractmethod
+    def add_label_with_title(self, title: str | None = None) -> None:
+        """Add label with title annotation
+
+        Args:
+            title: title (if None, use object title)
+        """
+
+    def iterate_shape_items(self, editable: bool = False):
+        """Iterate over shape items encoded in metadata (if any).
+
+        Args:
+            editable: if True, annotations are editable
+
+        Yields:
+            Plot item
+        """
+        fmt = self.get_obj_option("format")
+        lbl = self.get_obj_option("showlabel")
+        for key, _value in self.obj.metadata.items():
+            if key == ROI_KEY:
+                roi = self.obj.roi
+                if roi is not None:
+                    # Delayed import to avoid circular dependency
+                    # pylint: disable=import-outside-toplevel
+                    from datalab.adapters_plotpy.roi.factory import create_roi_adapter
+
+                    adapter = create_roi_adapter(roi)
+                    yield from adapter.iterate_roi_items(
+                        self.obj, fmt=fmt, lbl=lbl, editable=False
+                    )
+            # Process geometry results from metadata (using GeometryAdapter)
+            elif GeometryAdapter.match(key, _value):
+                try:
+                    geomadapter = GeometryAdapter.from_metadata_entry(self.obj, key)
+                    plot_adapter = GeometryPlotPyAdapter(geomadapter)
+                    yield from plot_adapter.iterate_shape_items(
+                        fmt, lbl, self.obj.PREFIX
+                    )
+                except (ValueError, TypeError):
+                    # Skip invalid entries
+                    pass
+        # Use the new annotation adapter to get items
+        if self.obj.has_annotations():
+            for item in self.annotation_adapter.get_items():
+                if isinstance(item, AnnotatedShape):
+                    config_annotated_shape(item, fmt, lbl)
+                set_plot_item_editable(item, editable)
+                yield item
+
+    def update_plot_item_parameters(self, item: TypePlotItem) -> None:
+        """Update plot item parameters from object data/metadata
+
+        Takes into account a subset of plot item parameters. Those parameters may
+        have been overriden by object metadata entries or other object data. The goal
+        is to update the plot item accordingly.
+
+        This is *almost* the inverse operation of `update_metadata_from_plot_item`.
+
+        Args:
+            item: plot item
+        """
+        def_dict = Conf.view.get_def_dict(self.__class__.__name__[:3].lower())
+        self.obj.set_metadata_options_defaults(def_dict, overwrite=False)
+
+        # Subclasses have to override this method to update plot item parameters,
+        # then call this implementation of the method to update plot item.
+        update_dataset(item.param, self.obj.get_metadata_options())
+        item.param.update_item(item)
+        if item.selected:
+            item.select()
+
+    def update_metadata_from_plot_item(self, item: TypePlotItem) -> None:
+        """Update metadata from plot item.
+
+        Takes into account a subset of plot item parameters. Those parameters may
+        have been modified by the user through the plot item GUI. The goal is to
+        update the metadata accordingly.
+
+        This is *almost* the inverse operation of `update_plot_item_parameters`.
+
+        Args:
+            item: plot item
+        """
+        def_dict = Conf.view.get_def_dict(self.__class__.__name__[:3].lower())
+        for key in def_dict:
+            if hasattr(item.param, key):  # In case the PlotPy version is not up-to-date
+                self.obj.set_metadata_option(key, getattr(item.param, key))