update mode

src/rougail/annotator/family.py

@@ -122,29 +122,44 @@ class FamilyAnnotator(Walk):
             return
         for variable in family.variable.values():
             if isinstance(variable, self.objectspace.family):
-                if family_mode and 'mode' not in vars(variable):
-                    variable.mode = family_mode
+                if family_mode and not self._has_mode(variable):
+                    self._set_auto_mode(variable, family_mode)
                 continue
             if isinstance(variable, self.objectspace.leadership):
                 func = self._set_default_mode_leader
             else:
                 func = self._set_default_mode_variable
-            func(variable)
+            func(variable, family_mode)
 
     @staticmethod
-    def _set_default_mode_variable(variable: 'self.objectspace.variable',
-                                  ) -> None:
+    def _has_mode(obj) -> bool:
+        return 'mode' in vars(obj) and not hasattr(obj, 'mode_auto')
+
+    def _set_default_mode_variable(self,
+                                   variable: 'self.objectspace.variable',
+                                   family_mode: str,
+                                   ) -> None:
         # auto_save or auto_freeze variable is set to 'basic' mode
         # if its mode is not defined by the user
-        if 'mode' not in vars(variable) and \
+        if not self._has_mode(variable) and \
                 (variable.auto_save is True or variable.auto_freeze is True):
-            variable.mode = modes_level[0]
+            self._set_auto_mode(variable, modes_level[0])
         # mandatory variable without value is a basic variable
-        if variable.mandatory is True and not hasattr(variable, 'default'):
-            variable.mode = modes_level[0]
+        elif variable.mandatory is True and \
+                not hasattr(variable, 'default') and \
+                not hasattr(variable, 'default_multi'):
+            self._set_auto_mode(variable, modes_level[0])
+        elif family_mode and not self._has_mode(variable):
+            self._set_auto_mode(variable, family_mode)
+
+    @staticmethod
+    def _set_auto_mode(obj, mode: str) -> None:
+        obj.mode = mode
+        obj.mode_auto = True
 
     def _set_default_mode_leader(self,
-                                 leadership,
+                                 leadership: 'self.objectspace.leadership',
+                                 family_mode: str,
                                  ) -> None:
         leader_mode = None
         for follower in leadership.variable:
@@ -154,14 +169,23 @@ class FamilyAnnotator(Walk):
             if follower.auto_freeze is True:
                 msg = f'leader/followers "{follower.name}" could not be auto_freeze'
                 raise DictConsistencyError(_(msg), 30, leadership.xmlfiles)
-            self._set_default_mode_variable(follower)
-            if leader_mode is None:
-                leader_mode = leadership.variable[0].mode
-            else:
+            if leader_mode is not None:
                 # leader's mode is minimum level
                 if modes[leader_mode] > modes[follower.mode]:
-                    follower.mode = leader_mode
-        leadership.mode = leader_mode
+                    if self._has_mode(follower) and not self._has_mode(leadership.variable[0]):
+                        self._set_auto_mode(leadership.variable[0], follower.mode)
+                    else:
+                        if self._has_mode(follower):
+                            msg = _(f'the follower "{follower.name}" is in "{follower.mode}" mode '
+                                    f'but leader have the higher mode "{leader_mode}"')
+                            raise DictConsistencyError(msg, 63, follower.xmlfiles)
+                        self._set_auto_mode(follower, leader_mode)
+            self._set_default_mode_variable(follower,
+                                            family_mode,
+                                            )
+            if leader_mode is None:
+                leader_mode = leadership.variable[0].mode
+        self._set_auto_mode(leadership, leadership.variable[0].mode)
 
     def _change_family_mode(self,
                            family: 'self.objectspace.family',
@@ -184,9 +208,13 @@ class FamilyAnnotator(Walk):
                          )
                 if modes[min_variable_mode] > modes[variable.mode]:
                     min_variable_mode = variable.mode
-        if hasattr(family, 'mode'):
+        if hasattr(family, 'mode') and family.mode != min_variable_mode:
             # set the lower variable mode to family
-            family.mode = min_variable_mode
+            if self._has_mode(family):
+                msg = _(f'the family "{family.name}" is in "{family.mode}" mode but variables and '
+                        f'families inside have the higher modes "{min_variable_mode}"')
+                raise DictConsistencyError(msg, 62, variable.xmlfiles)
+            self._set_auto_mode(family, min_variable_mode)
 
     def _change_variable_mode(self,
                              variable,
@@ -194,9 +222,12 @@ class FamilyAnnotator(Walk):
                              is_follower=False,
                              ) -> None:
         # none basic variable in high level family has to be in high level
-        if modes[variable.mode] < modes[family_mode] and \
-                (not is_follower or variable.mode != modes_level[0]):
-            variable.mode = family_mode
+        if modes[variable.mode] < modes[family_mode]:
+            if self._has_mode(variable):
+                msg = _(f'the variable "{variable.name}" is in "{variable.mode}" mode '
+                        f'but family has the higher family mode "{family_mode}"')
+                raise DictConsistencyError(msg, 61, variable.xmlfiles)
+            self._set_auto_mode(variable, family_mode)
 
     def _change_variable_mode_leader(self,
                                      leadership,