Fix validation ordering bug

Author: Andrzej Krupka

flow360/component/simulation/blueprint/core/resolver.py

@@ -99,7 +99,7 @@ def get_allowed_callable(self, qualname: str) -> Callable[..., Any]:
                 or qualname in self._module_builtins
                 or any(
                     qualname.startswith(f"{group['prefix']}{name}")
-                    for group in self._callable_builtins.values()
+                    for group in self._callable_builtins.values() if group is not None
                     for name in group["callables"]
                 )
             ):

flow360/component/simulation/primitives.py

@@ -88,7 +88,7 @@ class ReferenceGeometry(Flow360BaseModel):
     moment_length: Optional[Union[LengthType.Positive, LengthType.PositiveVector]] = pd.Field(
         None, description="The x, y, z component-wise moment reference lengths."
     )
-    area: Optional[ValueOrExpression[AreaType.Positive]] = pd.Field(
+    area: Optional[ValueOrExpression[AreaType]] = pd.Field(
         None, description="The reference area of the geometry."
     )
 

flow360/component/simulation/user_code.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from typing import get_origin, Generic, TypeVar, Optional, Iterable
 
-from pydantic import WrapSerializer, WrapValidator
+from pydantic import BeforeValidator, WrapSerializer, WrapValidator
 from typing_extensions import Self
 import re
 
@@ -20,13 +20,6 @@
 _user_variables: set[str] = set()
 
 
-def _is_descendant_of(t, base):
-    if t is None:
-        return False
-    origin = get_origin(t) or t
-    return issubclass(origin, base)
-
-
 def _is_number_string(s: str) -> bool:
     try:
         float(s)
@@ -208,9 +201,9 @@ class Expression(Flow360BaseModel):
 
     model_config = pd.ConfigDict(validate_assignment=True)
 
-    @pd.model_validator(mode="wrap")
+    @pd.model_validator(mode="before")
     @classmethod
-    def _validate_expression(cls, value, handler) -> Self:
+    def _validate_expression(cls, value) -> Self:
         if isinstance(value, str):
             expression = value
         elif isinstance(value, dict) and "expression" in value.keys():
@@ -234,7 +227,7 @@ def _validate_expression(cls, value, handler) -> Self:
             details = InitErrorDetails(type="value_error", ctx={"error": v_err})
             raise pd.ValidationError.from_exception_data("expression value error", [details])
 
-        return handler({"expression": expression})
+        return {"expression": expression}
 
     def evaluate(self, strict=True) -> float:
         expr = expression_to_model(self.expression, _global_ctx)
@@ -350,22 +343,22 @@ def _internal_validator(value: Expression):
 
         expr_type = Annotated[Expression, pd.AfterValidator(_internal_validator)]
 
-        def _deserialize(value, handler) -> Self:
+        def _deserialize(value) -> Self:
             try:
                 value = SerializedValueOrExpression.model_validate(value, strict=True)
                 if value.type_name == "number":
                     if value.units is not None:
-                        return handler(unyt_quantity(value.value, value.units))
+                        return unyt_quantity(value.value, value.units)
                     else:
-                        return handler(value.value)
+                        return value.value
                 elif value.type_name == "expression":
-                    return handler(value.expression)
+                    return expr_type(expression=value.expression)
             except Exception as err:
                 pass
 
-            return handler(value)
+            return value
 
-        def _serializer(value, handler, info) -> dict:
+        def _serializer(value, info) -> dict:
             if isinstance(value, Expression):
                 serialized = SerializedValueOrExpression(typeName="expression")
 
@@ -397,5 +390,9 @@ def _serializer(value, handler, info) -> dict:
                     serialized.units = str(value.units.expr)
 
             return serialized.model_dump(**info.__dict__)
+        
+        union_type = Union[expr_type, internal_type]
+        union_type = Annotated[union_type, PlainSerializer(_serializer)]
+        union_type = Annotated[union_type, BeforeValidator(_deserialize)]
 
-        return Annotated[Annotated[Union[expr_type, internal_type], WrapSerializer(_serializer)], WrapValidator(_deserialize)]
+        return union_type