WrappingFailure was renamed ValidationFailed for end-user readability

Author: Sylvain MARIE

valid8/__init__.py

@@ -33,7 +33,7 @@
     # -- utils_typing
     'Boolean', 'is_pep484_nonable',
     # -- base
-    'Failure', 'WrappingFailure', 'failure_raiser',
+    'Failure', 'ValidationFailed', 'failure_raiser',
     # -- composition
     'CompositionFailure', 'AtLeastOneFailed', 'and_', 'DidNotFail', 'not_', 'AllValidatorsFailed', 'or_',
     'XorTooManySuccess', 'xor_', 'not_all', 'fail_on_none', 'skip_on_none',

valid8/base.py

@@ -275,7 +275,7 @@ def __init__(self, wrong_value, condition, **kwargs):
     ```
 
     Note: if users wish to wrap an *existing* function (such as a lambda or mini lambda) with a Failure raiser, then
-    they should subclass `WrappingFailure` instead of `Failure`. See `WrappingFailure` for details.
+    they should subclass `ValidationFailed` instead of `Failure`. See `ValidationFailed` for details.
     """
 
     def __init__(self,
@@ -334,7 +334,7 @@ def get_details(self):
             return 'Wrong value: %s' % repr(self.wrong_value)
 
 
-class WrappingFailure(Failure):
+class ValidationFailed(Failure):
     """
     Represents a Failure associated with a wrapped validation function. It contains additional details about which
     validation function it was, and what was the outcome.
@@ -344,7 +344,7 @@ class WrappingFailure(Failure):
 
      * either use the syntax `(<wrapped_callable>, <help_msg>)` when defining validation functions, or explicitly call
      `failure_raiser(<wrapped_callable>, help_msg=<help_msg>)`. Both are equivalent and will create instances of
-     `WrappingFailure` with the provided help message when the wrapped callable fails.
+     `ValidationFailed` with the provided help message when the wrapped callable fails.
 
      * or subclass it explicitly (recommended) and then use the syntax `(<callable>, <subclass>)` or
      `failure_raiser(<wrapped_callable>, failure_type=<subclass>)`. Both are equivalent and will create instances of
@@ -355,7 +355,7 @@ class WrappingFailure(Failure):
     providing details about the failure is to override the 'help_msg' field:
 
     ```python
-    class SurfaceNotInValidRange(WrappingFailure):
+    class SurfaceNotInValidRange(ValidationFailed):
         help_msg = 'Surface should be a positive number less than 10000 (square meter)'
     ```
 
@@ -370,7 +370,7 @@ def __init__(self,
                  help_msg=None,             # type: str
                  **kw_context_args):
         """
-        Creates a WrappingFailure associated with failed validation of `wrong_value` by `wrapped_func`. Additional
+        Creates a ValidationFailed associated with failed validation of `wrong_value` by `wrapped_func`. Additional
         details about the validation outcome (result or exception) can be provided in validation_outcome.
 
         Contextual information may be provided as keyword arguments, and will be stored as fields in the created
@@ -396,7 +396,7 @@ def __init__(self,
         self.validation_outcome = validation_outcome
 
         # call super constructor
-        super(WrappingFailure, self).__init__(wrong_value=wrong_value, help_msg=help_msg, **kw_context_args)
+        super(ValidationFailed, self).__init__(wrong_value=wrong_value, help_msg=help_msg, **kw_context_args)
 
         # automatically set the exception as the cause, so that we can forget to "raise from"
         if isinstance(validation_outcome, Exception):
@@ -431,8 +431,8 @@ def get_context_for_help_msgs(self, context_dict):
 
 
 def failure_raiser(validation_callable,   # type: ValidationCallableOrLambda
-                   failure_type=None,     # type: Type[WrappingFailure]
                    help_msg=None,         # type: str
+                   failure_type=None,     # type: Type[ValidationFailed]
                    **kw_context_args):
     # type: (...) -> ValidationCallable
     """
@@ -469,7 +469,7 @@ def raiser(x):
 
         # if not result_is_success(res): <= DO NOT REMOVE THIS COMMENT
         if (res is not None) and (res is not True):
-            typ = failure_type or WrappingFailure
+            typ = failure_type or ValidationFailed
             exc = typ(wrapped_func=validation_callable, wrong_value=x, validation_outcome=res,
                       help_msg=help_msg, **kw_context_args)
             raise exc
@@ -538,7 +538,7 @@ def _none_rejecter(validation_callable  # type: ValidationCallable
     # type: (...) -> ValidationCallable
     """
     Wraps the given validation callable to reject None values. When a None value is received by the wrapper,
-    it is not passed to the validation_callable and instead this function will raise a WrappingFailure. When any other
+    it is not passed to the validation_callable and instead this function will raise a ValidationFailed. When any other
     value is received the validation_callable is called as usual.
 
     Important: mini-lambda expressions are NOT transformed into function. Indeed this function is internal only

valid8/common_syntax.py

@@ -1,7 +1,7 @@
 from itertools import chain
 from sys import version_info
 
-from valid8.base import failure_raiser, WrappingFailure, as_function
+from valid8.base import failure_raiser, ValidationFailed, as_function
 
 try:  # python 3.5+
     # noinspection PyUnresolvedReferences
@@ -18,14 +18,14 @@
         # 2. the syntax to optionally transform them into failure raisers by providing a tuple
         ValidationFuncDefinition = Union[ValidationCallableOrLambda,
                                          Tuple[ValidationCallableOrLambda, str],
-                                         Tuple[ValidationCallableOrLambda, Type[WrappingFailure]],
-                                         Tuple[ValidationCallableOrLambda, str, Type[WrappingFailure]]
+                                         Tuple[ValidationCallableOrLambda, Type[ValidationFailed]],
+                                         Tuple[ValidationCallableOrLambda, str, Type[ValidationFailed]]
                                          ]
         """Defines a checker from a base checker function together with optional error message and failure type 
         (in which case a failure raiser is created to wrap that function)"""
 
         # 3. the syntax to describe several validation functions at once
-        VFDefinitionElement = Union[str, Type[WrappingFailure], ValidationCallableOrLambda]
+        VFDefinitionElement = Union[str, Type[ValidationFailed], ValidationCallableOrLambda]
         """This type represents one of the elements that can define a checker"""
 
         OneOrSeveralVFDefinitions = Union[ValidationFuncDefinition,
@@ -79,7 +79,7 @@ def _make_validation_func_callable(vf_definition  # type: ValidationFuncDefiniti
     If `vf_definition` is a tuple such as (<validation_func>, <err_msg>), (<validation_func>, <failure_type>),
     or (<validation_func>, <err_msg>, <failure_type>), a `failure_raiser` is created.
 
-    >>> class MyFailure(WrappingFailure):
+    >>> class MyFailure(ValidationFailed):
     ...     pass
     >>> vf_with_details = _make_validation_func_callable((vf, 'blah', MyFailure))
     >>> vf_with_details('hello')
@@ -133,7 +133,7 @@ def _make_validation_func_callable(vf_definition  # type: ValidationFuncDefiniti
             # noinspection PyBroadException
             try:
                 # noinspection PyTypeChecker
-                if issubclass(failure_type, WrappingFailure):
+                if issubclass(failure_type, ValidationFailed):
                     failure_type_ok = True
             except:  # noqa: E722
                 pass
@@ -181,7 +181,7 @@ def _make_validation_func_callables(*vf_definition  # type: OneOrSeveralVFDefini
     >>> def is_minus_1(x): return x + 1 == 0
 
     >>> # a custom failure we would like to be raised
-    >>> class MyFailure(WrappingFailure):
+    >>> class MyFailure(ValidationFailed):
     ...     pass
 
     >>> # process both vf1 and v2, reusing vf1 'as is' and enriching vf2 with a custom failure type and error message

valid8/composition.py

@@ -4,7 +4,7 @@
 
 from makefun import with_signature
 
-from valid8.base import Failure, WrappingFailure, result_is_success, get_callable_names, get_callable_name, _none_accepter, _none_rejecter
+from valid8.base import Failure, ValidationFailed, get_callable_names, get_callable_name, _none_accepter, _none_rejecter
 from valid8.common_syntax import _make_validation_func_callables
 
 
@@ -70,7 +70,7 @@ def get_details(self):
         for validator, failure in self.failures.items():
             name = get_callable_name(validator)
             if isinstance(failure, Exception):
-                if isinstance(failure, WrappingFailure) or isinstance(failure, CompositionFailure):
+                if isinstance(failure, ValidationFailed) or isinstance(failure, CompositionFailure):
                     need_to_print_value = False
                 failures_for_print[name] = '{exc_type}: {msg}'.format(exc_type=type(failure).__name__, msg=str(failure))
             else:
@@ -173,7 +173,7 @@ def and_v_(x):
         return and_v_
 
 
-class DidNotFail(WrappingFailure):
+class DidNotFail(ValidationFailed):
     """ Raised by the not_ operator when the inner validation function did not fail."""
     help_msg = '{wrapped_func} validated value {wrong_value} with success, therefore the not() is a failure'
 

valid8/entry_points.py

@@ -174,7 +174,7 @@ def __init__(self, var_value, condition, **kwargs):
     ```
 
     Note: if users wish to wrap an *existing* function (such as a lambda or mini lambda) with a Failure raiser, then
-    they should subclass `WrappingFailure` instead of `Failure`. See `WrappingFailure` for details.
+    they should subclass `ValidationFailed` instead of `Failure`. See `ValidationFailed` for details.
     """
 
     @classmethod

valid8/tests/readme/test_readme_index.py

@@ -295,7 +295,7 @@ def test_readme_index_usage_customization():
     e = exc_info.value
     assert str(e) == 'Error validating [surface=-1]. ' \
                      'Validation function [is_multiple_of_100] raised ' \
-                     'WrappingFailure: Surface should be a multiple of 100. ' \
+                     'ValidationFailed: Surface should be a multiple of 100. ' \
                      'Function [is_multiple_of_100] raised ' \
                      '[IsNotMultipleOf: Value should be a multiple of 100. Wrong value: -1].'
 
@@ -377,9 +377,9 @@ class InvalidSurface(ValidationError):
                      "Validation function [and((x >= 0) & (x < 10000), is_multiple_of_100)] raised " \
                      "AtLeastOneFailed: At least one validation function failed validation. " \
                      "Successes: [] / Failures: {" \
-                     "'(x >= 0) & (x < 10000)': 'WrappingFailure: Surface should be between 0 and 10000. " \
+                     "'(x >= 0) & (x < 10000)': 'ValidationFailed: Surface should be between 0 and 10000. " \
                      "Function [(x >= 0) & (x < 10000)] returned [False] for value -1.', " \
-                     "'is_multiple_of_100': 'WrappingFailure: Surface should be a multiple of 100. " \
+                     "'is_multiple_of_100': 'ValidationFailed: Surface should be a multiple of 100. " \
                      "Function [is_multiple_of_100] raised [IsNotMultipleOf: Value should be a multiple of 100. " \
                      "Wrong value: -1].'}."
 
@@ -399,8 +399,8 @@ class InvalidSurface(ValidationError):
                      "Validation function [and((x >= 0) & (x < 10000), is_multiple_of_100)] raised " \
                      "AtLeastOneFailed: At least one validation function failed validation. " \
                      "Successes: [] / Failures: {" \
-                     "'(x >= 0) & (x < 10000)': 'WrappingFailure: Surface should be between 0 and 10000. " \
+                     "'(x >= 0) & (x < 10000)': 'ValidationFailed: Surface should be between 0 and 10000. " \
                      "Function [(x >= 0) & (x < 10000)] returned [False] for value -1.', " \
-                     "'is_multiple_of_100': 'WrappingFailure: Surface should be a multiple of 100, found -1. " \
+                     "'is_multiple_of_100': 'ValidationFailed: Surface should be a multiple of 100, found -1. " \
                      "Function [is_multiple_of_100] raised [IsNotMultipleOf: Value should be a multiple of 100. " \
                      "Wrong value: -1].'}."

valid8/validation_lib/collections.py

@@ -5,7 +5,7 @@
     pass
 
 from valid8.composition import and_
-from valid8.base import Failure, WrappingFailure, result_is_success, get_callable_name
+from valid8.base import Failure, ValidationFailed, get_callable_name
 
 
 class Empty(Failure, ValueError):
@@ -270,7 +270,7 @@ def is_superset_of(x):
     return is_superset_of
 
 
-class InvalidItemInSequence(WrappingFailure, ValueError):
+class InvalidItemInSequence(ValidationFailed, ValueError):
     """ Custom Failure raised by on_all_ and on_each_ """
     help_msg = 'Provided sequence contains one value that is invalid.'