Add ~ shortcut to negate shortcut

Sometimes negation is easier than
the positive specification.

Author: gfyoung

README.md

@@ -198,6 +198,24 @@ ValueError: Expected an odd integer
 2
 ~~~
 
+The shortcuts can also be negated if specifying the "not" condition is too complicated:
+
+~~~python
+import py_validate as pv
+
+@pv.validate_inputs(a="~number")  # The input must not be a number.
+def identity(a):
+    return a
+
+>>> identity(1)
+...
+py_validate.backend.shortcuts.NegateFailure: Failed validation for input 'a':
+Validation for 'number' passed when it shouldn't have
+
+>>> identity("foo")
+'foo'
+~~~
+
 When specifying validators for input variables, do note that once validators for a variable
 have been set, they cannot be changed. Doing so will cause an error to be raised:
 

py_validate/backend/__init__.py

@@ -3,4 +3,4 @@
 """
 
 from py_validate.backend.base import ValidatedFunction  # noqa
-from py_validate.backend.shortcuts import get_shortcut  # noqa
+from py_validate.backend.shortcuts import NegateShortcut, get_shortcut  # noqa

py_validate/backend/base.py

@@ -3,7 +3,7 @@
 """
 
 from .helpers import DocSubstitution, FrozenDict
-from .shortcuts import get_shortcut
+from .shortcuts import NegateShortcut, get_shortcut
 
 
 validator_doc = """If a string is provided, that means we are using a shortcut,
@@ -216,7 +216,10 @@ def raise_exception_failure(inp_name, e):
             raise type(e)(exception_failure.format(inp_name=inp_name) + str(e))
 
         if isinstance(validator, str):
-            validator = get_shortcut(validator)
+            if validator.startswith("~"):
+                validator = NegateShortcut(validator[1:])
+            else:
+                validator = get_shortcut(validator)
 
             try:
                 validator(val)

py_validate/backend/shortcuts.py

@@ -117,3 +117,29 @@ def get_shortcut(shortcut):
         raise ValueError(msg.format(shortcut=shortcut))
 
     return shortcut_func
+
+
+class NegateFailure(Exception):
+    """
+    Exception class for when a validation function passes when it shouldn't.
+    """
+
+    pass
+
+
+class NegateShortcut(object):
+
+    def __init__(self, shortcut):
+        self.shortcut = shortcut
+        self.func = get_shortcut(shortcut)
+        self.msg = ("Validation for '{shortcut}' "
+                    "passed when it shouldn't have")
+
+    def __call__(self, x):
+        try:
+            self.func(x)
+            raise NegateFailure(self.msg.format(shortcut=self.shortcut))
+        except NegateFailure:
+            raise
+        except (TypeError, ValueError):
+            pass

py_validate/tests/backend/test_base.py

@@ -41,7 +41,7 @@ def test_pv_namespace(self):
 
     def test_pv_backend_namespace(self):
         import py_validate.backend as backend
-        expected = {"ValidatedFunction", "base",
+        expected = {"NegateShortcut", "ValidatedFunction", "base",
                     "get_shortcut", "helpers", "shortcuts"}
 
         self._check_namespace(backend, expected)

py_validate/tests/backend/test_shortcuts.py

@@ -1,6 +1,7 @@
-import py_validate.backend.shortcuts as shortcuts
+from py_validate.backend.shortcuts import NegateShortcut
 from py_validate.tests import assert_raises
 
+import py_validate.backend.shortcuts as shortcuts
 import pytest
 
 
@@ -109,3 +110,37 @@ def test_invalid_odd_not_int(self, invalid):
     def test_invalid_even_not_even(self, invalid):
         msg = "Expected an odd integer"
         assert_raises(ValueError, msg, shortcuts.check_odd, invalid)
+
+
+class TestCheckNegateShortcut(object):
+
+    @pytest.mark.parametrize("invalid", [
+        "foo", "bar", "baz"
+    ])
+    def test_invalid_shortcut_negate(self, invalid):
+        msg = "Unknown shortcut"
+        assert_raises(ValueError, msg, NegateShortcut, invalid)
+
+    @pytest.mark.parametrize("valid,value", [
+        ("number", "foo"),
+        ("integer", 1.0),
+        ("even", 3),
+        ("odd", 2)
+    ])
+    def test_valid_negate(self, valid, value):
+
+        # No Exception should be raised.
+        negate_check = NegateShortcut(valid)
+        negate_check(value)
+
+    @pytest.mark.parametrize("valid,value", [
+        ("number", 1.5),
+        ("integer", 1),
+        ("even", 2),
+        ("odd", 3)
+    ])
+    def test_invalid_negate(self, valid, value):
+        msg = "passed when it shouldn't have"
+        negate_check = NegateShortcut(valid)
+
+        assert_raises(shortcuts.NegateFailure, msg, negate_check, value)

py_validate/tests/validator/test_inputs.py

@@ -2,6 +2,7 @@
 Unittests for the input validator decorator.
 """
 
+from py_validate.backend.shortcuts import NegateFailure
 from py_validate.validator import validate_inputs
 from py_validate.tests import assert_raises
 
@@ -186,3 +187,14 @@ def wrapper(a):
         msg = "Expected an odd integer"
         assert_raises(ValueError, msg, wrapper, 2)
         assert_raises(ValueError, msg, wrapper, 4)
+
+    def test_negate(self):
+        @validate_inputs(a="~number")
+        def wrapper(a):
+            return a
+
+        assert wrapper("foo") == "foo"
+        assert wrapper((1, 2, 3)) == (1, 2, 3)
+
+        msg = "'number' passed when it shouldn't have"
+        assert_raises(NegateFailure, msg, wrapper, 1)

py_validate/tests/validator/test_outputs.py

@@ -2,6 +2,7 @@
 Unittests for the output validator decorator.
 """
 
+from py_validate.backend.shortcuts import NegateFailure
 from py_validate.validator import validate_outputs
 from py_validate.tests import assert_raises
 
@@ -175,3 +176,15 @@ def wrapper(a):
 
         msg = "Expected an odd integer"
         assert_raises(ValueError, msg, wrapper, 2)
+
+    def test_negate(self):
+        @validate_outputs(-1, "~integer")
+        def wrapper(a):
+            return a
+
+        assert wrapper(1.5) == 1.5
+        assert wrapper("foo") == "foo"
+        assert wrapper((1, 2, 3)) == (1, 2, 3)
+
+        msg = "'integer' passed when it shouldn't have"
+        assert_raises(NegateFailure, msg, wrapper, 1)

py_validate/tests/validator/test_stacking.py

@@ -4,6 +4,7 @@
 """
 
 from py_validate.validator import validate_inputs, validate_outputs
+from py_validate.backend.shortcuts import NegateFailure
 from py_validate.tests import assert_raises
 
 
@@ -188,3 +189,21 @@ def wrapper(a):
 
     msg = "Expected an even integer"
     assert_raises(ValueError, msg, wrapper, 1)
+
+
+def test_negate_stack():
+    @validate_inputs(a="integer")
+    @validate_inputs(b="~number")
+    def wrapper(a, b):
+        return a * b
+
+    assert wrapper(2, "bar") == "barbar"
+    assert wrapper(3, [1, 2]) == [1, 2, 1, 2, 1, 2]
+
+    msg = "Expected an integer"
+    assert_raises(TypeError, msg, wrapper, "foo", "bar")
+    assert_raises(TypeError, msg, wrapper, [1, 2, 3], "bar")
+
+    msg = "'number' passed when it shouldn't have"
+    assert_raises(NegateFailure, msg, wrapper, 5, 5)
+    assert_raises(NegateFailure, msg, wrapper, 5, 12.1)