Move validation behind a feature flag.

I've added a module-level `FEATURE_FLAGS` object. This means validation of properties on set is disabled by default, but may be enabled if it's wanted.

The test suite checks both cases, and I've added a context manager to avoid accidental state leakage between tests.

Author: rwb27

src/labthings_fastapi/__init__.py

@@ -25,6 +25,7 @@
 from .properties import property, setting, DataProperty, DataSetting
 from .actions import action
 from .endpoints import endpoint
+from .feature_flags import FEATURE_FLAGS
 from . import outputs
 from .outputs import blob
 from .server import ThingServer, cli
@@ -52,6 +53,7 @@
     "action",
     "thing_slot",
     "endpoint",
+    "FEATURE_FLAGS",
     "outputs",
     "blob",
     "ThingServer",

src/labthings_fastapi/feature_flags.py

@@ -0,0 +1,57 @@
+"""Control of optional features in LabThings.
+
+This module provides a way to globally enable or disable certain features of LabThings.
+When a new, non-backwards-compatible feature is added, it will usually be disabled by
+default. This module provides an object `.FEATURE_FLAGS` that allows control over
+optional features.
+
+The default values of `.FEATURE_FLAGS` may change with new LabThings releases. The usual
+sequence of events would be that a new feature is added (disabled by default), then the
+feature flag is enabled by default in a subsequent release. If the intention is that the
+feature will become non-optional, disabling the feature will raise a
+`DeprecationWarning` for at least one release cycle before it is removed.
+"""
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class LabthingsFeatureFlags:
+    """Control over optional features of LabThings."""
+
+    validate_properties_on_set: bool = False
+    """Whether validation logic runs when properties are set in Python."""
+
+    @contextmanager
+    def set_temporarily(
+        self,
+        **kwargs: Any,
+    ) -> Iterator[None]:
+        r"""Temporarily set feature flags in a context manager.
+
+        This function may be used in a `with:` block to set feature flags and
+        then reset them afterwards. This is primarily useful for testing.
+
+        :param \**kwargs: the feature flags to set for the duration of the ``with:``
+            block. The argument names must match attributes of this object.
+
+        .. code-block: python
+
+           with FEATURE_FLAGS.set_temporarily(validate_properties_on_set=True):
+               my_thing.positive_int = -10  # Raises an exception
+
+        """
+        values_before = {k: getattr(self, k) for k in kwargs.keys()}
+        try:
+            for k, v in kwargs.items():
+                setattr(self, k, v)
+            yield
+        finally:
+            for k, v in values_before.items():
+                setattr(self, k, v)
+
+
+FEATURE_FLAGS = LabthingsFeatureFlags()

src/labthings_fastapi/properties.py

@@ -64,6 +64,7 @@ class attribute. Documentation is in strings immediately following the
 from fastapi import Body, FastAPI
 from pydantic import BaseModel, ConfigDict, RootModel, ValidationError, create_model
 
+from .feature_flags import FEATURE_FLAGS
 from .thing_description import type_to_dataschema
 from .thing_description._model import (
     DataSchema,
@@ -609,7 +610,10 @@ def __set__(
         :param emit_changed_event: whether to emit a changed event.
         """
         property_info = self.descriptor_info(obj)
-        obj.__dict__[self.name] = property_info.validate(value)
+        if FEATURE_FLAGS.validate_properties_on_set:
+            obj.__dict__[self.name] = property_info.validate(value)
+        else:
+            obj.__dict__[self.name] = value
         if emit_changed_event:
             self.emit_changed_event(obj, value)
 
@@ -812,7 +816,8 @@ def instance_get(self, obj: Owner) -> Value:
     def __set__(self, obj: Owner, value: Value) -> None:
         """Set the value of the property.
 
-        This will validate the value against the property's model, and an error
+        If property validation is enabled by `.FEATURE_FLAGS.validate_properties_on_set`
+        this will validate the value against the property's model, and an error
         will be raised if the value is not valid.
 
         :param obj: the `.Thing` on which the attribute is accessed.
@@ -823,7 +828,8 @@ def __set__(self, obj: Owner, value: Value) -> None:
         if self.fset is None:
             raise ReadOnlyPropertyError(f"Property {self.name} of {obj} has no setter.")
         property_info = self.descriptor_info(obj)
-        value = property_info.validate(value)
+        if FEATURE_FLAGS.validate_properties_on_set:
+            value = property_info.validate(value)
 
         self.fset(obj, value)
 

tests/test_properties.py

@@ -14,6 +14,7 @@
     ServerNotRunningError,
     UnsupportedConstraintError,
 )
+from labthings_fastapi.feature_flags import FEATURE_FLAGS
 from labthings_fastapi.properties import BaseProperty, PropertyInfo
 from labthings_fastapi.testing import create_thing_without_server
 from .temp_client import poll_task
@@ -409,13 +410,20 @@ def test_constrained_properties(prop_info, mocker):
         prop.__set__(mock_thing, valid)
         validated = prop.__get__(mock_thing)
         assert validated == valid or validated is valid  # `is` for NaN
+
     for invalid in prop_info.invalid_values:
         with pytest.raises(ValidationError):
             _ = m(root=invalid)
         with pytest.raises(ValidationError):
             descriptorinfo.validate(invalid)
-        with pytest.raises(ValidationError):
+        # We check that validation on __set__ only applies if it's enabled.
+        with FEATURE_FLAGS.set_temporarily(validate_properties_on_set=True):
+            with pytest.raises(ValidationError):
+                prop.__set__(mock_thing, invalid)
+        with FEATURE_FLAGS.set_temporarily(validate_properties_on_set=False):
             prop.__set__(mock_thing, invalid)
+            not_validated = prop.__get__(mock_thing)
+            assert not_validated == invalid or not_validated is invalid
 
 
 def convert_inf_nan(value):

tests/test_property.py

@@ -16,6 +16,7 @@
 import pydantic
 import pytest
 from labthings_fastapi import properties
+from labthings_fastapi.feature_flags import FEATURE_FLAGS
 from labthings_fastapi.properties import (
     BaseProperty,
     DataProperty,
@@ -365,8 +366,9 @@ class BadIntModel(pydantic.BaseModel):
     # Check that a broken `_model` raises the right error
     # See above for where we manually set badprop._model to something that's
     # not a rootmodel.
-    with pytest.raises(TypeError):
-        example.badprop = 3  # Validation will fail here because of the bad model.
+    with FEATURE_FLAGS.set_temporarily(validate_properties_on_set=True):
+        with pytest.raises(TypeError):
+            example.badprop = 3  # Validation will fail here because of the bad model.
     with pytest.raises(TypeError):
         _ = example.properties["badprop"].model_instance
     with pytest.raises(TypeError):