merge ValueWarning | ValueOptionError | ValueErrorWarning

tiramisu_json_api/api.py

@@ -178,19 +178,20 @@ class _Value:
 
     def _display_warnings(self, path, value, type, name, withwarning=True):
         for err in self.model.get(path, {}).get('error', []):
-            warnings.warn_explicit(ValueOptionError(value,
+            warnings.warn_explicit(ValueErrorWarning(value,
-                                                    type,
+                                                     type,
-                                                    Option(path),
+                                                     Option(path),
-                                                    '{0}'.format(err)),
+                                                     '{0}'.format(err)),
                                    ValueErrorWarning,
                                    self.__class__.__name__, 0)
 
         if withwarning and self.model.get(path, {}).get('warnings'):
             for warn in self.model.get(path, {}).get('warnings'):
-                # FIXME ValueWarning needs value and type attribute!
+                warnings.warn_explicit(ValueErrorWarning(value,
-                warnings.warn_explicit(ValueWarning('{0}'.format(warn),
+                                                         type,
-                                                    Option(path)),
+                                                         Option(path),
-                                       ValueWarning,
+                                                         '{0}'.format(err)),
+                                       ValueErrorWarning,
                                        self.__class__.__name__, 0)
 
 

tiramisu_json_api/error.py

@@ -37,55 +37,26 @@ except ModuleNotFoundError:
     class APIError(Exception):
         pass
 
-    # Warning
+    class _CommonError:
-    class ValueWarning(UserWarning):
-        """Option could warn user and not raise ValueError.
-
-        Example:
-
-        >>> import warnings
-        >>> from tiramisu.error import ValueWarning
-        >>> from tiramisu.option import StrOption, OptionDescription
-        >>> from tiramisu import Config
-        >>> warnings.simplefilter("always", ValueWarning)
-        >>> def a(val):
-        ...  raise ValueError('pouet')
-        ...
-        >>> s=StrOption('s', '', validator=a, warnings_only=True)
-        >>> o=OptionDescription('o', '', [s])
-        >>> c=Config(o)
-        >>> c.s = 'val'
-        StrOption:0: ValueWarning: invalid value val for option s: pouet
-        >>> with warnings.catch_warnings(record=True) as w:
-        ...     c.s = 'val'
-        ...
-        >>> w[0].message.opt() == s
-        True
-        >>> print(str(w[0].message))
-        invalid value val for option s: pouet
-        """
-        def __init__(self,
-                     msg,
-                     opt):
-            self.opt = opt
-            self.value_error = msg
-            super(ValueWarning, self).__init__(msg)
-
-    class ValueOptionError(ValueError):
         def __init__(self,
                      val,
                      display_type,
                      opt,
                      err_msg):
-            self.prefix = _('"{0}" is an invalid {1} for "{2}"'
+            self.val = val
-                            '').format(val,
+            self.display_type = display_type
-                                       display_type,
-                                       opt.impl_get_display_name())
             self.opt = weakref.ref(opt)
             self.err_msg = err_msg
+            super().__init__(self.err_msg)
 
         def __str__(self):
-            msg = self.prefix
+            try:
+                msg = self.prefix
+            except AttributeError:
+                self.prefix = self.tmpl.format(self.val,
+                                               self.display_type,
+                                               self.opt().impl_get_display_name())
+                msg = self.prefix
             if self.err_msg:
                 if msg:
                     msg += ', {}'.format(self.err_msg)
@@ -95,10 +66,14 @@ except ModuleNotFoundError:
                 msg = _('invalid value')
             return msg
 
+    class ValueWarning(_CommonError, UserWarning):
+        tmpl = _('attention, "{0}" could be an invalid {1} for "{2}"')
+
+    class ValueOptionError(_CommonError, ValueError):
+        tmpl = _('"{0}" is an invalid {1} for "{2}"')
+
     class ValueErrorWarning(ValueWarning):
-        def __init__(self,
+        tmpl = _('"{0}" is an invalid {1} for "{2}"')
-                     value_error):
-            super(ValueErrorWarning, self).__init__(value_error, value_error.opt)
 
     # Exceptions for an Option
     class PropertiesOptionError(AttributeError):