Program rewrite to allow all python versions

Author: Ge0rg3

README.md

@@ -4,7 +4,7 @@
 ## Install
 * Pip: Install with `pip install flask_parameter_validation`.
 * Manually:
-  - `git clone https://github.com/Ge0rg3/Flask-Parameter-Validation.git`
+  - `git clone https://github.com/Ge0rg3/flask-parameter-validation.git`
   - `python setup.py install`
 
 
@@ -56,8 +56,8 @@ The validation on files are different to the others, but file input can still be
 All parameters can have default values, and automatic validation.  
 `Route`, `Form`, `Json` and `Query` have the following options:
 * default: any, Specifies the default value for the field.
-* min_length: int, Specifies the minimum character length for a string input
-* max_length: int, Specifies the maximum character length for a string input
+* min_str_length: int, Specifies the minimum character length for a string input
+* max_str_length: int, Specifies the maximum character length for a string input
 * min_list_length: int, Specifies the minimum number of elements in a list
 * max_list_length: int, Specifies the maximum number of elements in a list
 * min_int: int, Specifies the minimum number for an int input

flask_parameter_validation/exceptions/__init__.py

@@ -0,0 +1,7 @@
+from .exceptions import MissingInputError, InvalidParameterTypeError, ValidationError
+
+__all__ = [
+    "MissingInputError",
+    "InvalidParameterTypeError",
+    "ValidationError"
+]

flask_parameter_validation/exceptions/exceptions.py

@@ -0,0 +1,28 @@
+class MissingInputError(Exception):
+    """Called if a user doesn't suppy a mandatory input"""
+    def __init__(self, expected_name, expected_type):
+        self.message = f"Missing required {expected_type.name} parameter '{expected_name}'."
+        super().__init__(expected_type.name, expected_name)
+
+    def __str__(self):
+        return self.message
+
+class InvalidParameterTypeError(Exception):
+    """Called if the developer supplies a non-standard parameter type"""
+    def __init__(self, invalid_type):
+        self.message = (
+            f"Invalid parameter type '{str(invalid_type)}' selected. "
+            "Please refer to the flask-parameter-validation documentation."
+        )
+        super().__init__(self.message)
+
+class ValidationError(Exception):
+    """Called if parameter validation fails""" 
+    def __init__(self, error_string, input_name, input_type):
+        self.message = (
+            f"Parameter '{input_name}' {error_string}"
+        )
+        super().__init__(error_string, input_name, input_type)
+    
+    def __str__(self):
+        return self.message

flask_parameter_validation/parameter_types/file.py

@@ -3,7 +3,7 @@
     - Would originally be in Flask's request.file
     - Value will be a FileStorage object
 """
-from .parameter import Parameter, ValidationError
+from .parameter import Parameter
 
 
 class File(Parameter):
@@ -25,21 +25,19 @@ def validate(self, value):
             # We check mimetype, as it strips charset etc.
             if value.mimetype not in self.content_types:
                 valid_types = "'" + "'/'".join(self.content_types) + "'"
-                raise ValidationError(f"must have content-type {valid_types}.")
+                raise ValueError(f"must have content-type {valid_types}.")
 
         # Min content length validation
         if self.min_length is not None:
             if value.content_length < self.min_length:
-                minlen = self.min_length
-                raise ValidationError(
-                    f"must have a content-length larger than {minlen}."
+                raise ValueError(
+                    f"must have a content-length larger than {self.min_length}."
                 )
 
         # Max content length validation
         if self.max_length is not None:
             if value.content_length > self.max_length:
-                maxlen = self.max_length
-                raise ValidationError(
-                    f"must have a content-length smaller than {maxlen}."
+                raise ValueError(
+                    f"must have a content-length smaller than {self.max_length}."
                 )
         return True

flask_parameter_validation/parameter_types/parameter.py

@@ -5,18 +5,14 @@
 import re
 
 
-class ValidationError(Exception):
-    pass
-
-
 class Parameter:
 
     # Parameter initialisation
     def __init__(
         self,
         default=None,  # any: default parameter value
-        min_length=None,  # int: min parameter length
-        max_length=None,  # int: max parameter length
+        min_str_length=None,  # int: min parameter length
+        max_str_length=None,  # int: max parameter length
         min_list_length=None,  # int: min number of items in list
         max_list_length=None,  # int: max number of items in list
         min_int=None,  # int: min number (if val is int)
@@ -26,66 +22,67 @@ def __init__(
         pattern=None,  # str: regexp pattern
     ):
         self.default = default
-        self.min_length = min_length
-        self.max_length = max_length
+        self.min_list_length = min_list_length
+        self.max_list_length = max_list_length
+        self.min_str_length = min_str_length
+        self.max_str_length = max_str_length
         self.min_int = min_int
         self.max_int = max_int
         self.whitelist = whitelist
         self.blacklist = blacklist
         self.pattern = pattern
 
     # Validator
-    def validate(self, values):
-        # Turn value into list if not already
-        if type(values) is not list:
-            values = [values]
-
-        # Check all values are valid
-        for value in values:
-            # Min length
-            if self.min_length is not None:
-                if len(value) < self.min_length:
-                    raise ValidationError(
-                        f"must be at least {self.min_length} characters."
-                    )
-            # Max length
-            if self.max_length is not None:
-                if len(value) > self.max_length:
-                    raise ValidationError(
-                        f"must be a maximum of {self.max_length} characters."
+    def validate(self, value):
+        # Min length
+        if self.min_str_length is not None:
+            if len(value) < self.min_str_length:
+                raise ValueError(
+                    f"must have at least {self.min_str_length} characters."
+                )
+        # Max length
+        if self.max_str_length is not None:
+            if len(value) > self.max_str_length:
+                raise ValueError(
+                    f"must have a maximum of {self.max_str_length} characters."
+                )
+        # Whitelist
+        if self.whitelist is not None:
+            for char in str(value):
+                if char not in self.whitelist:
+                    raise ValueError(
+                        f"must contain only characters: {self.whitelist}"
                     )
-            # Whitelist
-            if self.whitelist is not None:
-                for char in str(value):
-                    if char not in self.whitelist:
-                        raise ValidationError(
-                            f"must contain only characters: {self.whitelist}"
-                        )
-            # Blacklist
-            if self.blacklist is not None:
-                for bad in self.blacklist:
-                    if bad in str(value):
-                        raise ValidationError(
-                            f"must not contain: {bad}"
-                        )
-            # Min int
-            if self.min_int is not None:
-                if int(value) < self.min_int:
-                    raise ValidationError(
-                        f"must be larger than {self.min_int}."
-                    )
-            # Max int
-            if self.max_int is not None:
-                if int(value) > self.max_int:
-                    raise ValidationError(
-                        f"must be smaller than {self.max_int}."
+        # Blacklist
+        if self.blacklist is not None:
+            for bad in self.blacklist:
+                if bad in str(value):
+                    raise ValueError(
+                        f"must not contain: {bad}"
                     )
+        # Min int
+        if self.min_int is not None:
+            if int(value) < self.min_int:
+                raise ValueError(
+                    f"must be larger than {self.min_int}."
+                )
+        # Max int
+        if self.max_int is not None:
+            if int(value) > self.max_int:
+                raise ValueError(
+                    f"must be smaller than {self.max_int}."
+                )
 
-            # Regexp
-            if self.pattern is not None:
-                if not re.match(self.pattern, value):
-                    raise ValidationError(
-                        f"pattern does not match: {self.pattern}."
-                    )
+        # Regexp
+        if self.pattern is not None:
+            if not re.match(self.pattern, value):
+                raise ValueError(
+                    f"pattern does not match: {self.pattern}."
+                )
+
+        return True
 
-            return True
+    def convert(self, value, allowed_types):
+        """Some parameter types require manual type conversion (see Query)"""
+        return value
+        

flask_parameter_validation/parameter_types/query.py

@@ -10,3 +10,27 @@ class Query(Parameter):
 
     def __init__(self, default=None, **kwargs):
         super().__init__(default, **kwargs)
+
+    def convert(self, value, allowed_types):
+        """Convert query parameters to corresponding types."""
+        if type(value) == str:
+            # int conversion
+            if int in allowed_types:
+                try:
+                    value = int(value)
+                except ValueError:
+                    pass
+            # float conversion
+            if float in allowed_types:
+                try:
+                    value = float(value)
+                except ValueError:
+                    pass
+            # bool conversion
+            if bool in allowed_types:
+                if value.lower() == "true":
+                    value = True
+                elif value.lower() == "false":
+                    value = False
+
+        return super().convert(value, allowed_types)