Merge branch 'develop' into feature/env

Author: PierreRaybaut

CHANGELOG.md

@@ -2,7 +2,25 @@
 
 ## Version 3.13.0 ##
 
-💥 New features:
+✨ New features:
+
+* `guidata.configtools.get_icon`:
+  * This function retrieves a QIcon from the specified image file.
+  * Now supports Qt standard icons (e.g. "MessageBoxInformation" or "DialogApplyButton").
+
+* Added a `readonly` parameter to `StringItem` and `TextItem` in `guidata.dataset.dataitems`:
+  * This allows these items to be set as read-only, preventing user edits in the GUI.
+  * The `readonly` property is now respected in the corresponding widgets (see `guidata.dataset.qtitemwidgets`).
+  * Example usage:
+
+    ```python
+    text = gds.TextItem("Text", default="Multi-line text", readonly=True)
+    string = gds.StringItem("String", readonly=True)
+    ```
+
+  * Note: Any other item type can also be turned into read-only mode by using `set_prop("display", readonly=True)`. This is a generic mechanism, but the main use case is for `StringItem` and `TextItem` (hence the dedicated input parameter for convenience).
+
+* [Issue #94](https://github.com/PlotPyStack/guidata/issues/94) - Make dataset description text selectable
 
 * New validation modes for `DataItem` objects:
   * Validation modes allow you to control how `DataItem` values are validated when they are set.
@@ -28,6 +46,12 @@
   * If `allow_none` is set to `False`, `None` is considered an invalid value.
   * The default value for `allow_none` is `False`, except for `FloatArrayItem`, `ColorItem` and `ChoiceItem` and its subclasses, where it is set to `True` by default.
 
+* Enhanced default value handling for `DataItem` objects:
+  * Default values can now be `None` even when `allow_none=False` is set on the item.
+  * This allows developers to use `None` as a sensible default value while still preventing users from setting `None` at runtime.
+  * This feature provides better flexibility for data item initialization without compromising runtime validation.
+  * The implementation uses a clean internal architecture that separates default value setting from regular value setting, maintaining the standard Python descriptor protocol.
+
 * Improved type handling in `IntItem` and `FloatItem`:
   * `IntItem` and `FloatItem` now automatically convert NumPy numeric types (like `np.int32` or `np.float64`) to native Python types (`int` or `float`) during validation
   * `FloatItem` now accepts integer values and silently converts them to float values

guidata/configtools.py

@@ -197,8 +197,19 @@ def get_icon(name: str, default: str = "not_found.png") -> QG.QIcon:
     try:
         return ICON_CACHE[name]
     except KeyError:
-        # Importing Qt here because this module should be independent from it
-        from qtpy import QtGui as QG  # pylint: disable=import-outside-toplevel
+        # Importing Qt objects here because this module should not depend on them
+        # pylint: disable=import-outside-toplevel
+
+        # Try to get standard icon first
+        from guidata.qthelpers import get_std_icon
+
+        try:
+            return get_std_icon(name)
+        except AttributeError:
+            pass
+
+        # Retrieve icon from file (original implementation)
+        from qtpy import QtGui as QG
 
         icon = QG.QIcon(get_image_file_path(name, default))
         ICON_CACHE[name] = icon

guidata/dataset/dataitems.py

@@ -278,8 +278,10 @@ def __init__(
         self.set_prop("display", slider=slider)
         self.set_prop("data", step=step)
 
-    def __set__(self, instance: Any, value: Any) -> None:
-        """Override DataItem.__set__ to convert integers to float"""
+    def _set_value_with_validation(
+        self, instance: Any, value: Any, force_allow_none: bool = False
+    ) -> None:
+        """Override DataItem._set_value_with_validation to convert integers to float"""
         # Try to convert NumPy numeric types to Python float
         # (will convert silently either floating point or integer types to float)
         try:
@@ -291,7 +293,7 @@ def __set__(self, instance: Any, value: Any) -> None:
         # (no more NumPy types at this point)
         if isinstance(value, int):
             value = float(value)
-        super().__set__(instance, value)
+        super()._set_value_with_validation(instance, value, force_allow_none)
 
     def get_value_from_reader(
         self, reader: HDF5Reader | JSONReader | INIReader
@@ -362,16 +364,19 @@ def get_auto_help(self, instance: DataSet) -> str:
                 auto_help += ", " + _("odd")
         return auto_help
 
-    def __set__(self, instance: Any, value: Any) -> None:
-        """Override DataItem.__set__ to convert NumPy numeric types to int"""
+    def _set_value_with_validation(
+        self, instance: Any, value: Any, force_allow_none: bool = False
+    ) -> None:
+        """Override DataItem._set_value_with_validation
+        to convert NumPy numeric types to int"""
         # Try to convert NumPy integer types to Python int
         # (will convert silently only integer types to int)
         try:
             if isinstance(value, np.integer):
                 value = self.type(value)
         except (TypeError, ValueError):
             pass
-        super().__set__(instance, value)
+        super()._set_value_with_validation(instance, value, force_allow_none)
 
     def check_value(self, value: int, raise_exception: bool = False) -> bool:
         """Override DataItem method"""
@@ -410,6 +415,7 @@ class StringItem(DataItem):
         check: if False, value is not checked (ineffective for strings)
         allow_none: if True, None is a valid value regardless of other constraints
          (optional, default=False)
+        readonly: if True, the item is read-only (optional, default=False)
     """
 
     type: Any = str
@@ -425,12 +431,15 @@ def __init__(
         help: str = "",
         check: bool = True,
         allow_none: bool = False,
+        readonly: bool = False,
     ) -> None:
         super().__init__(
             label, default=default, help=help, check=check, allow_none=allow_none
         )
         self.set_prop("data", notempty=notempty, regexp=regexp)
-        self.set_prop("display", wordwrap=wordwrap, password=password)
+        self.set_prop(
+            "display", wordwrap=wordwrap, password=password, readonly=readonly
+        )
 
     def get_auto_help(self, instance: DataSet) -> str:
         """Override DataItem method"""
@@ -492,6 +501,7 @@ class TextItem(StringItem):
         help: text shown in tooltip (optional)
         allow_none: if True, None is a valid value regardless of other constraints
          (optional, default=False)
+        readonly: if True, the item is read-only (optional, default=False)
     """
 
     def __init__(
@@ -502,6 +512,7 @@ def __init__(
         wordwrap: bool = True,
         help: str = "",
         allow_none: bool = False,
+        readonly: bool = False,
     ) -> None:
         super().__init__(
             label,
@@ -510,6 +521,7 @@ def __init__(
             wordwrap=wordwrap,
             help=help,
             allow_none=allow_none,
+            readonly=readonly,
         )
 
 
@@ -1015,11 +1027,13 @@ def get_value(self, instance: DataSet) -> str | None:
         # guidata internals should call this; keep it returning the raw key
         return super().__get__(instance, instance.__class__)  # string (or None)
 
-    def __set__(self, instance: DataSet, value: Any) -> None:
-        """Override DataItem.__set__ to accept Enum members"""
+    def _set_value_with_validation(
+        self, instance: Any, value: Any, force_allow_none: bool = False
+    ) -> None:
+        """Override DataItem._set_value_with_validation to accept Enum members"""
         if self._enum_cls is not None and value is not None:
             value = self._enum_coerce_in(value)  # → member.name
-        super().__set__(instance, value)
+        super()._set_value_with_validation(instance, value, force_allow_none)
 
     def _normalize_choice(
         self, idx: int, choice_tuple: tuple[Any, ...]

guidata/dataset/datatypes.py

@@ -550,7 +550,8 @@ def set_default(self, instance: DataSet) -> None:
             instance (DataSet): instance of the DataSet
         """
         try:
-            self.__set__(instance, deepcopy(self._default))
+            value = deepcopy(self._default)
+            self._set_value_with_validation(instance, value, force_allow_none=True)
         except ValueError as exc:
             # Convert generic ValueError to a more specific DataItemValidationError
             # to provide clearer context when setting default values fails
@@ -585,12 +586,26 @@ def __set__(self, instance: Any, value: Any) -> None:
             instance (Any): instance of the DataSet
             value (Any): value to set
         """
+        self._set_value_with_validation(instance, value, force_allow_none=False)
+
+    def _set_value_with_validation(
+        self, instance: Any, value: Any, force_allow_none: bool = False
+    ) -> None:
+        """Internal method to set data item's value with validation
+
+        Args:
+            instance (Any): instance of the DataSet
+            value (Any): value to set
+            force_allow_none (bool): if True, allow None values even when
+             allow_none is False (used for default values)
+        """
         vmode = get_validation_mode()
 
-        # If value is None and allow_none is True, skip validation
+        # Determine if validation should be skipped
         allow_none = self.get_prop("data", "allow_none", False)
+        skip_validation = value is None and (allow_none or force_allow_none)
 
-        if vmode != ValidationMode.DISABLED and not (value is None and allow_none):
+        if vmode != ValidationMode.DISABLED and not skip_validation:
             try:
                 self.check_value(value, raise_exception=True)
             except NotImplementedError:

guidata/dataset/qtitemwidgets.py

@@ -152,7 +152,9 @@ def is_readonly(self) -> bool:
         Returns:
             True if associated dataset is readonly
         """
-        return self.item.instance.is_readonly()
+        return self.item.instance.is_readonly() or self.item.get_prop_value(
+            "display", "readonly", False
+        )
 
     def check(self) -> bool:
         """Item validator

guidata/dataset/qtwidgets.py

@@ -126,6 +126,7 @@ def __init__(
         self._layout = QVBoxLayout()
         if instance.get_comment():
             label = QLabel(instance.get_comment())
+            label.setTextInteractionFlags(Qt.TextSelectableByMouse)
             label.setWordWrap(wordwrap)
             self._layout.addWidget(label)
         self.instance = instance
@@ -275,6 +276,7 @@ def setup_instance(self, instance: DataSetGroup) -> None:
             layout.setAlignment(Qt.AlignmentFlag.AlignTop)
             if dataset.get_comment():
                 label = QLabel(dataset.get_comment())
+                label.setTextInteractionFlags(Qt.TextSelectableByMouse)
                 label.setWordWrap(self.wordwrap)
                 layout.addWidget(label)
             grid = QGridLayout()
@@ -772,6 +774,7 @@ def __init__(
         self._layout = QVBoxLayout()
         if self.dataset.get_comment():
             label = QLabel(self.dataset.get_comment())
+            label.setTextInteractionFlags(Qt.TextSelectableByMouse)
             label.setWordWrap(wordwrap)
             self._layout.addWidget(label)
         self.grid_layout = QGridLayout()
@@ -1067,6 +1070,7 @@ def __init__(
         self._layout = QVBoxLayout()
         if instance.get_comment():
             label = QLabel(instance.get_comment())
+            label.setTextInteractionFlags(Qt.TextSelectableByMouse)
             label.setWordWrap(wordwrap)
             self._layout.addWidget(label)
         self.instance = instance

guidata/tests/dataset/test_button_item.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the BSD 3-Clause
+# (see guidata/LICENSE for details)
+
+"""
+Button item test
+
+This item is tested separately from other items because it is special: contrary to
+other items, it is purely GUI oriented and has no sense in a non-GUI context.
+"""
+
+# guitest: show
+
+from __future__ import annotations
+
+import os.path as osp
+import re
+
+from qtpy import QtCore as QC
+from qtpy import QtWidgets as QW
+
+import guidata.dataset as gds
+from guidata.env import execenv
+from guidata.qthelpers import qt_app_context
+
+
+def information_selectable(parent: QW.QWidget, title: str, text: str) -> None:
+    """Show an information message box with selectable text.
+    Dialog box is *not* modal."""
+    box = QW.QMessageBox(parent)
+    box.setIcon(QW.QMessageBox.Information)
+    box.setWindowTitle(title)
+    if re.search(r"<[a-zA-Z/][^>]*>", text):
+        box.setTextFormat(QC.Qt.RichText)
+        box.setTextInteractionFlags(QC.Qt.TextBrowserInteraction)
+    else:
+        box.setTextFormat(QC.Qt.PlainText)
+        box.setTextInteractionFlags(
+            QC.Qt.TextSelectableByMouse | QC.Qt.TextSelectableByKeyboard
+        )
+    box.setText(text)
+    box.setStandardButtons(QW.QMessageBox.Close)
+    box.setDefaultButton(QW.QMessageBox.Close)
+    box.setWindowFlags(QC.Qt.Window)  # This is necessary only on non-Windows platforms
+    box.setModal(False)
+    box.show()
+
+
+class Parameters(gds.DataSet):
+    """
+    DataSet test
+    The following text is the DataSet 'comment': <br>Plain text or
+    <b>rich text<sup>2</sup></b> are both supported,
+    as well as special characters (α, β, γ, δ, ...)
+    """
+
+    def button_cb(
+        dataset: Parameters, item: gds.ButtonItem, value: None, parent: QW.QWidget
+    ) -> None:
+        """Button callback"""
+        execenv.print(f"Button clicked: {dataset}, {item}, {value}, {parent}")
+        text = "<br>".join(
+            [
+                f"<b>Dataset</b>: {'<br>' + '<br>'.join(str(dataset).splitlines())}",
+                f"<b>Item</b>: {item}",
+                f"<b>Value</b>: {value}",
+            ]
+        )
+        information_selectable(parent, "Button Clicked", text)
+
+    dir = gds.DirectoryItem("Directory", osp.dirname(__file__))
+    pattern = gds.StringItem("File pattern", "*.py")
+    button = gds.ButtonItem("Help", button_cb, "MessageBoxInformation").set_pos(col=1)
+    preview = gds.TextItem("File names preview")
+
+
+def test_button_item():
+    """Test button item"""
+    with qt_app_context():
+        prm = Parameters()
+        execenv.print(prm)
+        if prm.edit():
+            execenv.print(prm)
+
+
+if __name__ == "__main__":
+    test_button_item()