safeshield 1.2.2__py3-none-any.whl → 1.4.2__py3-none-any.whl

validator/rules/numeric.py

@@ -0,0 +1,188 @@
+from .base import Rule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+import decimal
+
+class NumericRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if isinstance(value, (int, float)):
+            return True
+        if not isinstance(value, str):
+            return False
+        return value.replace('.', '', 1).isdigit()
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be a number."
+    
+class IntegerRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if isinstance(value, int):
+            return True
+        if not isinstance(value, str):
+            return False
+        return value.isdigit()
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be an integer."
+
+class DigitsRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params or not isinstance(value, str):
+            return False
+            
+        try:
+            digits = int(params[0])
+        except ValueError:
+            return False
+            
+        return value.isdigit() and len(value) == digits
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be {params[0]} digits."
+
+class DigitsBetweenRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 2 or not isinstance(value, str):
+            return False
+            
+        try:
+            min_digits = int(params[0])
+            max_digits = int(params[1])
+        except ValueError:
+            return False
+            
+        return value.isdigit() and min_digits <= len(value) <= max_digits
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be between {params[0]} and {params[1]} digits."
+    
+class DecimalRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        try:
+            decimal.Decimal(str(value))
+            return True
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return "The :attribute must be a decimal number."
+
+class GreaterThanRule(Rule):
+    _name = 'gt'
+    
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 1:
+            return False
+        
+        try:
+            threshold = decimal.Decimal(params[0])
+            numeric_value = decimal.Decimal(str(value))
+            return numeric_value > threshold
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be greater than {params[0]}."
+
+class GreaterThanOrEqualRule(Rule):
+    _name = 'gte'
+    
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 1:
+            return False
+        
+        try:
+            threshold = decimal.Decimal(params[0])
+            numeric_value = decimal.Decimal(str(value))
+            return numeric_value >= threshold
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be greater than or equal to {params[0]}."
+
+class LessThanRule(Rule):
+    _name = 'lt'
+    
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 1:
+            return False
+        
+        try:
+            threshold = decimal.Decimal(params[0])
+            numeric_value = decimal.Decimal(str(value))
+            return numeric_value < threshold
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be less than {params[0]}."
+
+class LessThanOrEqualRule(Rule):
+    _name = 'lte'
+    
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 1:
+            return False
+        
+        try:
+            threshold = decimal.Decimal(params[0])
+            numeric_value = decimal.Decimal(str(value))
+            return numeric_value <= threshold
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be less than or equal to {params[0]}."
+
+class MaxDigitsRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 1:
+            return False
+        
+        try:
+            max_digits = int(params[0])
+            numeric_value = decimal.Decimal(str(value))
+            str_value = str(numeric_value).replace("-", "")
+            if '.' in str_value:
+                str_value = str_value.replace(".", "")
+            return len(str_value) <= max_digits
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must not exceed {params[0]} digits."
+
+class MinDigitsRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 1:
+            return False
+        
+        try:
+            min_digits = int(params[0])
+            numeric_value = decimal.Decimal(str(value))
+            str_value = str(numeric_value).replace("-", "")
+            if '.' in str_value:
+                str_value = str_value.replace(".", "")
+            return len(str_value) >= min_digits
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must have at least {params[0]} digits."
+
+class MultipleOfRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+            
+        try:
+            divisor = float(params[0])
+            if divisor == 0:
+                return False
+            num = float(value)
+            return num % divisor == 0
+        except (ValueError, TypeError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be a multiple of {params[0]}."

validator/rules/string.py

@@ -1,4 +1,4 @@
-from .base import ValidationRule
+from .base import Rule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 import re
 
@@ -6,69 +6,121 @@ import re
 # STRING VALIDATION RULES
 # =============================================
 
-class StringRule(ValidationRule):
+class StringRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         return isinstance(value, str)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a string."
+        return f"The :attribute must be a string."
 
-class AlphaRule(ValidationRule):
+class AlphaRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         return isinstance(value, str) and value.isalpha()
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name may only contain letters."
+        return f"The :attribute may only contain letters."
 
-class AlphaDashRule(ValidationRule):
+class AlphaDashRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         return isinstance(value, str) and bool(re.match(r'^[a-zA-Z0-9_-]+$', value))
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name may only contain letters, numbers, dashes and underscores."
+        return f"The :attribute may only contain letters, numbers, dashes and underscores."
 
-class AlphaNumRule(ValidationRule):
+class AlphaNumRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         return isinstance(value, str) and value.isalnum()
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name may only contain letters and numbers."
+        return f"The :attribute may only contain letters and numbers."
 
-class UppercaseRule(ValidationRule):
+class UppercaseRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         return isinstance(value, str) and value == value.upper()
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be uppercase."
+        return f"The :attribute must be uppercase."
 
-class LowercaseRule(ValidationRule):
+class LowercaseRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         return isinstance(value, str) and value == value.lower()
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be lowercase."
+        return f"The :attribute must be lowercase."
 
-class AsciiRule(ValidationRule):
+class AsciiRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         return isinstance(value, str) and all(ord(c) < 128 for c in value)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must only contain ASCII characters."
+        return f"The :attribute must only contain ASCII characters."
     
-class StartsWithRule(ValidationRule):
+class StartsWithRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, str):
             return False
         return any(value.startswith(p) for p in params)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must start with one of the following: {', '.join(params)}."
+        return f"The :attribute must start with one of the following: {', '.join(params)}."
+    
+class DoesntStartWithRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str) or not params:
+            return False
+        return all(not value.startswith(prefix) for prefix in params)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must not start with any of: {', '.join(params)}"
 
-class EndsWithRule(ValidationRule):
+class EndsWithRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, str):
             return False
         return any(value.endswith(p) for p in params)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must end with one of the following: {', '.join(params)}."
+        return f"The :attribute must end with one of the following: {', '.join(params)}."
+    
+class DoesntEndWithRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str) or not params:
+            return False
+        return all(not value.endswith(suffix) for suffix in params)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must not end with any of: {', '.join(params)}"
+    
+class ConfirmedRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        confirmation_field = f"{field}_confirmation"
+        
+        return value == self.get_field_value(confirmation_field, '') 
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute confirmation does not match."
+    
+class RegexRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params or not isinstance(value, str):
+            return False
+        try:
+            return bool(re.fullmatch(params[0], value))
+        except re.error:
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute format is invalid."
+
+class NotRegexRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params or not isinstance(value, str):
+            return True
+        print(not bool(re.search(params[0], value)))
+        try:
+            return not bool(re.search(params[0], value))
+        except re.error:
+            return True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute format is invalid."