fix(typed_state): fix decoder with annotations

- Fix TypedState decoder when used with dataclasses in files containing
  from __future__ import annotations.
  Import triggers a lazy evaluation for the dataclass fields method and
  field.type contains strings instead of actual types.
- Change default encode / decode behavior to raise a TypeError when
  Serialization fails instead of silently returning unchanged object.

Author: Thibault-Pelletier

tests/test_typed_state.py

@@ -419,3 +419,21 @@ def test_handles_list_of_union(state):
     typed_state.data.my_optional_enum_list = [b_str, b_enum, None]
     assert typed_state.data.my_optional_enum_list == [b_enum, b_enum, None]
     assert state[typed_state.name.my_optional_enum_list] == [b_str, b_str, None]
+
+
+def test_failure_to_encode_raises_type_error(state):
+    class RaiseEncode(DefaultEncoderDecoder):
+        def encode(self, _obj):
+            raise AssertionError()
+
+        def decode(self, _obj, _obj_type: type):
+            raise AssertionError()
+
+    typed_state = TypedState(state, DataWithTypes, encoders=[RaiseEncode()])
+    state.setdefault(typed_state.name.my_enum, MyEnum.A.value)
+
+    with pytest.raises(TypeError):
+        typed_state.data.my_enum = MyEnum.A
+
+    with pytest.raises(TypeError):
+        print(typed_state.data.my_enum)

tests/test_typed_state_future_annotations.py

@@ -0,0 +1,33 @@
+from __future__ import annotations  # triggers lazy evaluation of field.type
+
+from dataclasses import dataclass
+from enum import Enum, auto
+
+import pytest
+
+from trame_server import Server
+from trame_server.utils.typed_state import TypedState
+
+
+class AnEnum(Enum):
+    A = auto()
+    B = auto()
+
+
+@dataclass
+class DataWithTypesAnnotations:
+    my_enum: AnEnum
+
+
+@pytest.fixture
+def state():
+    server = Server()
+    server.state.ready()
+    return server.state
+
+
+def test_is_compatible_with_from_future_annotations(state):
+    typed_state = TypedState(state, DataWithTypesAnnotations)
+    typed_state.data.my_enum = AnEnum.B
+    assert typed_state.data.my_enum == AnEnum.B
+    assert state[typed_state.name.my_enum] == AnEnum.B.value

trame_server/utils/typed_state.py

@@ -17,6 +17,7 @@
     cast,
     get_args,
     get_origin,
+    get_type_hints,
 )
 from uuid import UUID
 
@@ -124,7 +125,9 @@ def encode(self, obj):
             val = self._try_serialize(encoder.encode, obj)
             if self.is_serialization_success(val):
                 return val
-        return obj
+
+        _error_msg = f"Failed to encode object {obj}. No appropriate encoder in {self._encoders}."
+        raise TypeError(_error_msg)
 
     @classmethod
     def _is_iterable(cls, obj):
@@ -140,7 +143,9 @@ def decode(self, obj, obj_type: type):
         val = self._try_decode(obj, obj_type)
         if self.is_serialization_success(val):
             return val
-        return obj
+
+        _error_msg = f"Failed to decode object {obj} of type {obj_type}. No appropriate decoder in {self._encoders}."
+        raise TypeError(_error_msg)
 
     def _try_decode(self, obj, obj_type: type):
         for decode in self._decode_strategies():
@@ -361,14 +366,14 @@ def _create_state_proxy(
         """
         encoder = encoder or CollectionEncoderDecoder(None)
 
-        def handler(state_id: str, field: Field):
+        def handler(state_id: str, field: Field, field_type: type):
             return _ProxyField(
                 state=state,
                 state_id=state_id,
                 name=field.name,
                 default=field.default,
                 default_factory=field.default_factory,
-                field_type=field.type,
+                field_type=field_type,
                 state_encoder=encoder,
             )
 
@@ -385,7 +390,7 @@ def _create_state_names_proxy(cls, dataclass_type: Type[T], *, namespace="") ->
             namespace prefix.
         """
 
-        def handler(state_id: str, _field: Field):
+        def handler(state_id: str, _field: Field, _field_type: type):
             return _NameField(state_id=state_id)
 
         return cls._build_proxy_cls(dataclass_type, namespace, handler, "__ProxyName")
@@ -395,7 +400,7 @@ def _build_proxy_cls(
         cls,
         dataclass_type: Type[T],
         prefix: str,
-        handler: Callable[[str, Field], Any],
+        handler: Callable[[str, Field, type], Any],
         cls_suffix: str,
         proxy_field_dict: dict | None = None,
     ) -> T:
@@ -415,14 +420,19 @@ def _build_proxy_cls(
         class_name = dataclass_type.__name__
         inner_field_dict = {}
         prefix = f"{prefix}__{class_name}" if prefix else class_name
+
+        # Use type hints instead of field.type to avoid lazy evaluation of field.type when used in files containing
+        # from __future__ import annotations header.
+        field_types = get_type_hints(dataclass_type)
         for f in fields(dataclass_type):
             state_id = f"{prefix}__{f.name}"
-            if is_dataclass(f.type):
+            f_type = field_types[f.name]
+            if is_dataclass(f_type):
                 field = cls._build_proxy_cls(
-                    f.type, state_id, handler, cls_suffix, inner_field_dict
+                    f_type, state_id, handler, cls_suffix, inner_field_dict
                 )
             else:
-                field = handler(state_id, f)
+                field = handler(state_id, f, f_type)
 
             inner_field_dict[cls.get_state_id(field, state_id)] = field
             namespace[f.name] = field