code cleanup, add make_validator decorator

Author: Andreas Hartl-Bachinger

decorator_validation/__init__.py

@@ -1,4 +1,4 @@
-from .decorators import check_types # noqa
+from .decorators import check_types, make_validator # noqa
 from .types import SkipTypeCheck # noqa
 import decorator_validation.types
 import decorator_validation.std_validators # noqa

decorator_validation/decorators.py

@@ -1,9 +1,9 @@
 from functools import wraps
+from typing import Callable, Any
 import inspect
 from .helpers import Annotation
 
 
-
 class check_types:
     """Decorator to automatically check input types of a function based on type annotation"""
 
@@ -54,3 +54,15 @@ def inner(*args, **kwargs):
             return func(*args, **kwargs)
 
         return inner
+
+
+def make_validator(func: Callable[[Any], None]) -> Callable[[Any], bool]:
+    """takes in function that raises error for wrong type and makes it return
+    True if no exception occurs"""
+
+    @wraps(func)
+    def inner(*args, **kwargs):
+        func(*args, **kwargs)
+        return True
+
+    return inner

decorator_validation/std_validators.py

@@ -1,15 +1,17 @@
 from typing import Union, Tuple, Iterable, Sequence
 from pathlib import Path
+from .decorators import make_validator
 
 
-def is_file(file: Union[str, Path]) -> bool:
+@make_validator
+def is_file(file: Union[str, Path]) -> None:
     """check if file is a file"""
     if not Path(file).resolve().is_file():
         raise TypeError(f"File {file} does not exist!")
-    return True
 
 
 def is_iterable_of(type_: Union[type, Tuple[type]]):
+    @make_validator
     def check_fn(arg: Iterable):
         if not isinstance(arg, Iterable):
             raise TypeError("Argument has to be an iterable!")
@@ -19,12 +21,12 @@ def check_fn(arg: Iterable):
                     f"Argument has to be an iterable with elements of type {type_},\
                           but an element with type {type(a)} occured"
                 )
-        return True
 
     return check_fn
 
 
 def is_sequence_of(type_: Union[type, Tuple[type]]):
+    @make_validator
     def check_fn(arg: Sequence):
         if not isinstance(arg, Sequence):
             raise TypeError("Argument has to be an iterable!")
@@ -34,16 +36,12 @@ def check_fn(arg: Sequence):
                     f"Argument has to be a sequence with elements of type {type_},\
                           but an element with type {type(a)} occured"
                 )
-        return True
 
     return check_fn
 
 
+@make_validator
 def is_num_as_str(number: str):
     if not isinstance(number, str):
         raise TypeError(f"{number} is not of type str but of type {type(number)}")
-    try:
-        float(number)
-        return True
-    except Exception:
-        return False
+    float(number)  # fails if not possible

examples/basic_examples.py

@@ -0,0 +1,60 @@
+from decorator_validation import check_types
+
+# check the types of your function
+
+
+@check_types
+def foo(a: int, b: int):
+    return a * b
+
+
+foo(2, 2, 3.3)  # returns 6
+foo(2.0, 3)  # raises TypeError as argument a has no correct type
+
+# to overwrite args pass in key mappings to the decorator.
+# Types have to be wrapped with a tuple
+
+
+@check_types(b=(int, float))
+def foo(a: int, b: int):
+    return a * b
+
+
+foo(2, 3)  # returns 6
+foo(2, 3.0)  # returns 6.0
+foo(2.0, 3)  # raises typeerror
+
+# You can also use functions to validate certain inputs
+
+from decorator_validation.std_validators import is_file
+
+
+@check_types(file=is_file)
+def write_to_file(file: str, text: str): ...
+
+
+write_to_file("non_existing_file.txt", "hello file")  # will raise a type-error if file does not exist.
+
+# You can also define custom "validators". Just make sure the function takes in the function input as an argument
+# and returns True if it is valid. In case it is'nt, raise an exception with a custom message or return False.
+
+
+def is_divisible_by_10(number: int | float):
+    return number % 10 == 0
+
+
+# recommended version would use exceptions though for a more readable error msg
+def is_divisible_by_10_better(number: int | float):
+    if not number % 10 == 0:
+        raise ValueError("Input Argument is not divisible by 10")
+    return True
+
+
+# for the above example you can use the utility decorator to make the code even more concise
+from decorator_validation import make_validator
+
+
+@make_validator
+def is_divisible_by_10_best(number: int | float):
+    if not number % 10 == 0:
+        raise ValueError("Input Argument is not divisible by 10")