Allow None defaults when allow_none=False

Default values can now be None even when allow_none=False
Enables flexible initialization while maintaining runtime validation
Refactored validation logic to eliminate code duplication
Maintains Python descriptor protocol compatibility

Author: PierreRaybaut

CHANGELOG.md

@@ -28,6 +28,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/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/tests/unit/test_force_allow_none.py

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the BSD 3-Clause
+# (see guidata/LICENSE for details)
+
+"""
+Test None default values with allow_none=False
+
+This test verifies that DataItem objects can have None as default values
+even when allow_none=False is set, while still preventing users from
+setting None values at runtime.
+"""
+
+import pytest
+
+from guidata.config import ValidationMode, set_validation_mode
+from guidata.dataset import DataSet
+from guidata.dataset.dataitems import StringItem
+from guidata.dataset.datatypes import DataItemValidationError
+
+
+class _TestDataSet(DataSet):
+    """Test dataset for None default values"""
+
+    name = StringItem("Name", default=None, allow_none=False)
+    description = StringItem("Description", default=None, allow_none=True)
+    title = StringItem("Title", default="Default Title", allow_none=False)
+
+
+def test_none_defaults_creation():
+    """Test that datasets can be created with None defaults even when
+    allow_none=False"""
+    # Set validation to strict mode to catch any issues
+    set_validation_mode(ValidationMode.STRICT)
+
+    # This should work: None default is allowed even when allow_none=False
+    dataset = _TestDataSet()
+
+    # Verify the default values are set correctly
+    assert dataset.name is None
+    assert dataset.description is None
+    assert dataset.title == "Default Title"
+
+
+def test_allow_none_true_accepts_none():
+    """Test that items with allow_none=True accept None values at runtime"""
+    set_validation_mode(ValidationMode.STRICT)
+    dataset = _TestDataSet()
+
+    # This should work: allow_none=True
+    dataset.description = None
+    assert dataset.description is None
+
+    # Should also accept valid string values
+    dataset.description = "Test Description"
+    assert dataset.description == "Test Description"
+
+
+def test_allow_none_false_rejects_none():
+    """Test that items with allow_none=False reject None values at runtime"""
+    set_validation_mode(ValidationMode.STRICT)
+    dataset = _TestDataSet()
+
+    # This should fail: allow_none=False
+    with pytest.raises(DataItemValidationError):
+        dataset.name = None
+
+
+def test_allow_none_false_accepts_valid_values():
+    """Test that items with allow_none=False accept valid non-None values"""
+    set_validation_mode(ValidationMode.STRICT)
+    dataset = _TestDataSet()
+
+    # This should work: valid string value
+    dataset.name = "Test Name"
+    assert dataset.name == "Test Name"
+
+    # Test changing values
+    dataset.name = "Another Name"
+    assert dataset.name == "Another Name"
+
+
+def test_validation_mode_disabled():
+    """Test that validation is skipped when validation mode is disabled"""
+    set_validation_mode(ValidationMode.DISABLED)
+    dataset = _TestDataSet()
+
+    # Even with allow_none=False, None should be accepted in disabled mode
+    dataset.name = None
+    assert dataset.name is None
+
+
+def test_validation_mode_enabled_warnings():
+    """Test that warnings are shown instead of exceptions in enabled mode"""
+    set_validation_mode(ValidationMode.ENABLED)
+    dataset = _TestDataSet()
+
+    # Should show warnings but not raise exceptions
+    with pytest.warns(UserWarning):
+        dataset.name = None
+    assert dataset.name is None
+
+
+@pytest.fixture(autouse=True)
+def reset_validation_mode():
+    """Reset validation mode after each test"""
+    yield
+    set_validation_mode(ValidationMode.DISABLED)  # Reset to default