New empty and non_empty built-in validators in validation_lib. New empty argument in validate. Fixes #31

Author: Sylvain MARIE

valid8/entry_points_inline.py

@@ -7,7 +7,7 @@
 from valid8.entry_points import Validator, ValidationError, NonePolicy, assert_valid
 from valid8.validation_lib.types import HasWrongType, IsWrongType
 from valid8.validation_lib.collections import NotInAllowedValues, TooLong, TooShort, WrongLength, DoesNotContainValue, \
-    NotSubset, NotSuperset
+    NotSubset, NotSuperset, NotEmpty, Empty
 from valid8.validation_lib.comparables import TooSmall, TooBig, NotEqual
 
 try:  # python 3.5+
@@ -136,6 +136,7 @@ def validate(name,                   # type: str
              max_value=None,         # type: Any
              max_strict=False,       # type: bool
              length=None,            # type: int
+             empty=None,             # type: bool
              min_len=None,           # type: int
              max_len=None,           # type: int
              custom=None,            # type: Callable[[Any], Any]
@@ -169,6 +170,7 @@ def validate(name,                   # type: str
     :param min_strict: if True, only values strictly greater than `min_value` will be accepted
     :param max_value: an optional maximum value
     :param max_strict: if True, only values strictly lesser than `max_value` will be accepted
+    :param empty: if `True` should be empty, if `False` should be non-empty. Default: `None` (not checked)
     :param length: an optional strict length
     :param min_len: an optional minimum length
     :param max_len: an optional maximum length
@@ -261,6 +263,15 @@ def validate(name,                   # type: str
                     if not value <= max_value:
                         raise TooBig(wrong_value=value, max_value=max_value, strict=False)
 
+            if empty:
+                # inlined version of empty() without 'return True'
+                if len(value) > 0:
+                    raise NotEmpty(wrong_value=value)
+            elif empty is not None:
+                # inlined version of not_empty() without 'return True'
+                if len(value) == 0:
+                    raise Empty(wrong_value=value)
+
             if length is not None:
                 # inlined version of has_length() without 'return True'
                 if len(value) != length:

valid8/tests/readme/test_readme_combining.py

@@ -117,11 +117,11 @@ def test_unused_pytypes():
     from pytypes import typechecked, InputTypeError
 
     # for value checking
-    from valid8 import validate_io, minlens, gt
+    from valid8 import validate_io, non_empty, gt
 
     from ._tests_pep484 import create_for_test_unused_pytypes
     build_house = create_for_test_unused_pytypes()
-    build_house = validate_io(name=minlens(0), surface=gt(0))(build_house)
+    build_house = validate_io(name=non_empty, surface=gt(0))(build_house)
     build_house = typechecked(build_house)
 
     build_house('test', 12, 2)  # validation OK

valid8/tests/test_entry_points_inline.py

@@ -1,7 +1,7 @@
 import sys
 
 import pytest
-from valid8 import ValidationError, validate, validator
+from valid8 import ValidationError, validate, validator, NotEmpty, Empty
 
 try:
     from math import isfinite
@@ -230,6 +230,20 @@ def __len__(self):
             validate('Foo()', Foo(), min_len=0, max_len=10)
 
 
+def test_empty_not_empty():
+    validate('x', [], empty=True)
+
+    with pytest.raises(ValidationError) as exc_info:
+        validate('x', [1], empty=True)
+    assert isinstance(exc_info.value.validation_outcome, NotEmpty)
+
+    validate('x', [1], empty=False)
+
+    with pytest.raises(ValidationError) as exc_info:
+        validate('x', [], empty=False)
+    assert isinstance(exc_info.value.validation_outcome, Empty)
+
+
 @pytest.mark.skipif(sys.version_info < (3, 0), reason="type hints not supported in python 2")
 def test_function_setter_name_in_valid8_error_message():
     """ Tests that the correct function name appears in the valid8 error message """

valid8/tests/validation_lib/test_validators_collections.py

@@ -2,7 +2,7 @@
 
 from mini_lambda import make_lambda_friendly_method, _, x
 from valid8 import on_each_, is_even, maxlen, on_all_, is_subset, is_superset, is_in, Failure, minlen, TooShort, \
-    TooLong, length_between, LengthNotInRange, lt, contains, has_length, WrongLength
+    TooLong, length_between, LengthNotInRange, lt, contains, has_length, WrongLength, empty, NotEmpty, non_empty, Empty
 
 
 def test_is_in():
@@ -82,11 +82,18 @@ def test_maxlen():
         maxlen(1)(['a', 'a'])
 
 
-def test_maxlens():
-    """ tests that the maxlens() function works """
-    with pytest.raises(TooLong):
-        maxlens(1)(['a'])
-    assert maxlens(3)(['a', 'a'])
+def test_empty():
+    """ tests that the empty() function works """
+    assert empty([])
+    with pytest.raises(NotEmpty):
+        empty(['a', 'a'])
+
+
+def test_nonempty():
+    """ tests that the non_empty() function works """
+    assert non_empty(['a', 'a'])
+    with pytest.raises(Empty):
+        non_empty([])
 
 
 def test_length_between():

valid8/validation_lib/__init__.py

@@ -1,7 +1,7 @@
 from .types import HasWrongType, IsWrongType, instance_of, subclass_of
 from .collections import TooLong, TooShort, minlen, maxlen, WrongLength, has_length,\
     LengthNotInRange, length_between, NotInAllowedValues, is_in, NotSubset, is_subset, DoesNotContainValue, contains,\
-    NotSuperset, is_superset, InvalidItemInSequence, on_all_, on_each_
+    NotSuperset, is_superset, InvalidItemInSequence, on_all_, on_each_, non_empty, Empty, empty, NotEmpty
 from .comparables import NotEqual, TooSmall, gt, gts, TooBig, lt, lts, NotInRange, between
 from .numbers import IsNotEven, is_even, IsNotOdd, is_odd, is_multiple_of, IsNotMultipleOf
 
@@ -10,7 +10,8 @@
     'types', 'collections', 'comparables', 'numbers',
     # symbols
     'HasWrongType', 'IsWrongType', 'instance_of', 'subclass_of',
-    'TooLong', 'TooShort', 'minlen', 'maxlen', 'WrongLength', 'has_length', 'LengthNotInRange',
+    'TooLong', 'TooShort', 'minlen', 'maxlen', 'WrongLength', 'has_length',
+    'non_empty', 'Empty', 'empty', 'NotEmpty', 'LengthNotInRange',
     'length_between', 'NotInAllowedValues', 'is_in', 'NotSubset', 'is_subset', 'DoesNotContainValue', 'contains',
     'NotSuperset', 'is_superset', 'InvalidItemInSequence', 'on_all_', 'on_each_',
     'NotEqual', 'TooSmall', 'gt', 'gts', 'TooBig', 'lt', 'lts', 'NotInRange', 'between',

valid8/validation_lib/collections.py

@@ -7,6 +7,40 @@
 from valid8.base import Failure, WrappingFailure, result_is_success, get_callable_name
 
 
+class Empty(Failure, ValueError):
+    """ Custom Failure raised by non_empty """
+    def __init__(self, wrong_value):
+        help_msg = 'len(x) > 0 does not hold for x={wrong_value}'
+        super(Empty, self).__init__(wrong_value=wrong_value, help_msg=help_msg)
+
+
+def non_empty(x):
+    """
+    'non empty' validation function. Raises a `Empty` error in case of validation failure.
+    """
+    if len(x) > 0:
+        return True
+    else:
+        raise Empty(wrong_value=x)
+
+
+class NotEmpty(Failure, ValueError):
+    """ Custom Failure raised by non_empty """
+    def __init__(self, wrong_value):
+        help_msg = 'len(x) == 0 does not hold for x={wrong_value}'
+        super(NotEmpty, self).__init__(wrong_value=wrong_value, help_msg=help_msg)
+
+
+def empty(x):
+    """
+    'is empty' validation function. Raises a `NotEmpty` error in case of validation failure.
+    """
+    if len(x) == 0:
+        return True
+    else:
+        raise NotEmpty(wrong_value=x)
+
+
 class TooShort(Failure, ValueError):
     """ Custom Failure raised by minlen """
     def __init__(self, wrong_value, min_length):