Removed the useless 'strict' length validators: removed min_len_strict and max_len_strict in validate entry point, and removed strict argument in validation_lib's minlen and maxlen. Indeed length is an integer by python framework definition, so it is always more compact to do +1 or -1 to the number. Fixes #29

Author: Sylvain MARIE

valid8/entry_points_inline.py

@@ -137,9 +137,7 @@ def validate(name,                   # type: str
              max_strict=False,       # type: bool
              length=None,            # type: int
              min_len=None,           # type: int
-             min_len_strict=False,   # type: bool
              max_len=None,           # type: int
-             max_len_strict=False,   # type: bool
              custom=None,            # type: Callable[[Any], Any]
              error_type=None,        # type: Type[ValidationError]
              help_msg=None,          # type: str
@@ -153,8 +151,7 @@ def validate(name,                   # type: str
        * if `allowed_values` is provided, `value` should be in that set
        * if `min_value` (resp. `max_value`) is provided, `value` should be greater than it. Comparison is not strict by
        default and can be set to strict by setting `min_strict`, resp. `max_strict`, to `True`
-       * if `min_len` (resp. `max_len`) is provided, `len(value)` should be greater than it. Comparison is not strict by
-       default and can be set to strict by setting `min_len_strict`, resp. `max_len_strict`, to `True`
+       * if `min_len` (resp. `max_len`) is provided, `len(value)` should be greater than it. Comparison is not strict.
 
     :param name: the applicative name of the checked value, that will be used in error messages
     :param value: the value to check
@@ -174,9 +171,7 @@ def validate(name,                   # type: str
     :param max_strict: if True, only values strictly lesser than `max_value` will be accepted
     :param length: an optional strict length
     :param min_len: an optional minimum length
-    :param min_len_strict: if True, only values with length strictly greater than `min_len` will be accepted
     :param max_len: an optional maximum length
-    :param max_len_strict: if True, only values with length strictly lesser than `max_len` will be accepted
     :param custom: a custom base validation function or list of base validation functions to use. This is the same
         syntax than for valid8 decorators. A callable, a tuple(callable, help_msg_str), a tuple(callable, failure_type),
         or a list of several such elements. Nested lists are supported and indicate an implicit `and_`. Tuples indicate
@@ -272,22 +267,14 @@ def validate(name,                   # type: str
                     raise WrongLength(wrong_value=value, ref_length=length)
 
             if min_len is not None:
-                # inlined version of minlen(min_length=min_len, strict=min_len_strict)(value) without 'return True'
-                if min_len_strict:
-                    if not len(value) > min_len:
-                        raise TooShort(wrong_value=value, min_length=min_len, strict=True)
-                else:
-                    if not len(value) >= min_len:
-                        raise TooShort(wrong_value=value, min_length=min_len, strict=False)
+                # inlined version of minlen(min_length=min_len)(value) without 'return True'
+                if len(value) < min_len:
+                    raise TooShort(wrong_value=value, min_length=min_len)
 
             if max_len is not None:
-                # inlined version of maxlen(max_length=max_len, strict=max_len_strict)(value) without 'return True'
-                if max_len_strict:
-                    if not len(value) < max_len:
-                        raise TooLong(wrong_value=value, max_length=max_len, strict=True)
-                else:
-                    if not len(value) <= max_len:
-                        raise TooLong(wrong_value=value, max_length=max_len, strict=False)
+                # inlined version of maxlen(max_length=max_len)(value) without 'return True'
+                if len(value) > max_len:
+                    raise TooLong(wrong_value=value, max_length=max_len)
 
     except Exception as e:
         err = _QUICK_VALIDATOR._create_validation_error(name, value, validation_outcome=e, error_type=error_type,

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, \
-    minlens, TooLong, length_between, maxlens, LengthNotInRange, lt, contains, has_length, WrongLength
+    TooLong, length_between, LengthNotInRange, lt, contains, has_length, WrongLength
 
 
 def test_is_in():
@@ -75,13 +75,6 @@ def test_minlen():
         minlen(1)([])
 
 
-def test_minlens():
-    """ tests that the minlens() function works """
-    with pytest.raises(TooShort):
-        minlens(1)(['a'])
-    assert minlens(1)(['a', 'a'])
-
-
 def test_maxlen():
     """ tests that the maxlen() function works """
     assert maxlen(1)(['a'])

valid8/validation_lib/__init__.py

@@ -1,5 +1,5 @@
 from .types import HasWrongType, IsWrongType, instance_of, subclass_of
-from .collections import TooLong, TooShort, minlen, minlens, maxlen, maxlens, WrongLength, has_length,\
+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_
 from .comparables import NotEqual, TooSmall, gt, gts, TooBig, lt, lts, NotInRange, between
@@ -10,7 +10,7 @@
     'types', 'collections', 'comparables', 'numbers',
     # symbols
     'HasWrongType', 'IsWrongType', 'instance_of', 'subclass_of',
-    'TooLong', 'TooShort', 'minlen', 'minlens', 'maxlen', 'maxlens', 'WrongLength', 'has_length', 'LengthNotInRange',
+    '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_',
     'NotEqual', 'TooSmall', 'gt', 'gts', 'TooBig', 'lt', 'lts', 'NotInRange', 'between',

valid8/validation_lib/collections.py

@@ -9,93 +9,57 @@
 
 class TooShort(Failure, ValueError):
     """ Custom Failure raised by minlen """
-    def __init__(self, wrong_value, min_length, strict):
-        symbol = '>' if strict else '>='
-        help_msg = 'len(x) {symbol} {min_length} does not hold for x={wrong_value}'
-        super(TooShort, self).__init__(wrong_value=wrong_value, min_length=min_length, symbol=symbol, help_msg=help_msg)
+    def __init__(self, wrong_value, min_length):
+        help_msg = 'len(x) >= {min_length} does not hold for x={wrong_value}'
+        super(TooShort, self).__init__(wrong_value=wrong_value, min_length=min_length, help_msg=help_msg)
 
 
-def minlen(min_length,
-           strict=False  # type: bool
+def minlen(min_length
            ):
     """
     'Minimum length' validation_function generator.
-    Returns a validation_function to check that len(x) >= min_length (strict=False, default)
-    or len(x) > min_length (strict=True)
+    Returns a validation_function to check that len(x) >= min_length
 
     :param min_length: minimum length for x
-    :param strict: Boolean flag to switch between len(x) >= min_length (strict=False) and len(x) > min_length
-    (strict=True)
     :return:
     """
-    if strict:
-        def minlen_(x):
-            if len(x) > min_length:
-                return True
-            else:
-                # raise Failure('minlen: len(x) > ' + str(min_length) + ' does not hold for x=' + str(x))
-                raise TooShort(wrong_value=x, min_length=min_length, strict=True)
-    else:
-        def minlen_(x):
-            if len(x) >= min_length:
-                return True
-            else:
-                # raise Failure('minlen: len(x) >= ' + str(min_length) + ' does not hold for x=' + str(x))
-                raise TooShort(wrong_value=x, min_length=min_length, strict=False)
+    def minlen_(x):
+        if len(x) >= min_length:
+            return True
+        else:
+            raise TooShort(wrong_value=x, min_length=min_length)
 
-    minlen_.__name__ = 'length_{}greater_than_{}'.format('strictly_' if strict else '', min_length)
+    minlen_.__name__ = 'length_greater_than_%s' % min_length
     return minlen_
 
 
-def minlens(min_length_strict):
-    """ Alias for 'Minimum length' validation_function generator in strict mode """
-    return minlen(min_length_strict, True)
-
-
 class TooLong(Failure, ValueError):
     """ Custom Failure raised by maxlen """
-    def __init__(self, wrong_value, max_length, strict):
-        symbol = '<' if strict else '<='
-        help_msg = 'len(x) {symbol} {max_length} does not hold for x={wrong_value}'
-        super(TooLong, self).__init__(wrong_value=wrong_value, max_length=max_length, symbol=symbol, help_msg=help_msg)
+    def __init__(self, wrong_value, max_length):
+        help_msg = 'len(x) <= {max_length} does not hold for x={wrong_value}'
+        super(TooLong, self).__init__(wrong_value=wrong_value, max_length=max_length, help_msg=help_msg)
 
 
 def maxlen(max_length,
-           strict=False  # type: bool
            ):
     """
     'Maximum length' validation_function generator.
-    Returns a validation_function to check that len(x) <= max_length (strict=False, default) or len(x) < max_length (strict=True)
+    Returns a validation_function to check that len(x) <= max_length
 
     :param max_length: maximum length for x
-    :param strict: Boolean flag to switch between len(x) <= max_length (strict=False) and len(x) < max_length
-    (strict=True)
     :return:
     """
-    if strict:
-        def maxlen_(x):
-            if len(x) < max_length:
-                return True
-            else:
-                # raise Failure('maxlen: len(x) < ' + str(max_length) + ' does not hold for x=' + str(x))
-                raise TooLong(wrong_value=x, max_length=max_length, strict=True)
-    else:
-        def maxlen_(x):
-            if len(x) <= max_length:
-                return True
-            else:
-                # raise Failure('maxlen: len(x) <= ' + str(max_length) + ' does not hold for x=' + str(x))
-                raise TooLong(wrong_value=x, max_length=max_length, strict=False)
+    def maxlen_(x):
+        if len(x) <= max_length:
+            return True
+        else:
+            # raise Failure('maxlen: len(x) <= ' + str(max_length) + ' does not hold for x=' + str(x))
+            raise TooLong(wrong_value=x, max_length=max_length)
 
-    maxlen_.__name__ = 'length_{}lesser_than_{}'.format('strictly_' if strict else '', max_length)
+    maxlen_.__name__ = 'length_lesser_than_%s' % max_length
     return maxlen_
 
 
-def maxlens(max_length_strict):
-    """ Alias for 'Maximum length' validation_function generator in strict mode """
-    return maxlen(max_length_strict, True)
-
-
 class WrongLength(Failure, ValueError):
     """ Custom failure raised by has_length """
     def __init__(self, wrong_value, ref_length):