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

validator/rules/comparison.py

@@ -1,11 +1,11 @@
-from .base import ValidationRule
-from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+from .base import Rule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type, Callable
 
 # =============================================
 # COMPARISON VALIDATION RULES
 # =============================================
 
-class MinRule(ValidationRule):
+class MinRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
@@ -27,9 +27,9 @@ class MinRule(ValidationRule):
         return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be at least {params[0]}."
+        return f"The :attribute must be at least {params[0]}."
 
-class MaxRule(ValidationRule):
+class MaxRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params or len(params) < 1:
             return False
@@ -85,15 +85,15 @@ class MaxRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         value = self.get_field_value(field)
         if value is None:
-            return f"The {field} must not exceed {params[0]}"
+            return f"The :attribute must not exceed {params[0]}"
             
         # Check all possible file size attributes
         file_attrs = ['content_length', 'size', 'fileno']
         if any(hasattr(value, attr) for attr in file_attrs):
-            return f"File {field} must not exceed {params[0]} bytes"
-        return f"The {field} must not exceed {params[0]}"
+            return f"File :attribute must not exceed {params[0]} bytes"
+        return f"The :attribute must not exceed {params[0]}"
 
-class BetweenRule(ValidationRule):
+class BetweenRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if len(params) != 2:
             return False
@@ -136,10 +136,10 @@ class BetweenRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         value = self.get_field_value(field)
         if hasattr(value, 'content_length') or hasattr(value, 'size'):
-            return f"File {field} must be between {params[0]} and {params[1]} bytes"
-        return f"The {field} must be between {params[0]} and {params[1]}"
+            return f"File :attribute must be between {params[0]} and {params[1]} bytes"
+        return f"The :attribute must be between {params[0]} and {params[1]}"
 
-class SizeRule(ValidationRule):
+class SizeRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params or len(params) < 1:
             return False
@@ -182,59 +182,149 @@ class SizeRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         value = self.get_field_value(field)
         if value is None:
-            return f"The {field} must be exactly {params[0]}"
+            return f"The :attribute must be exactly {params[0]}"
             
         # Check for file attributes
         file_attrs = ['content_length', 'size', 'fileno']
         if any(hasattr(value, attr) for attr in file_attrs):
-            return f"File {field} must be exactly {params[0]} bytes"
+            return f"File :attribute must be exactly {params[0]} bytes"
             
-        return f"The {field} must be exactly {params[0]}"
+        return f"The :attribute must be exactly {params[0]}"
     
-class DigitsRule(ValidationRule):
+
+class UniqueRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or not isinstance(value, str):
+        if not params or not hasattr(self.validator, 'db_manager') or not self.validator.db_manager:
             return False
             
+        table = params[0]
+        column = field if len(params) == 1 else params[1]
+        
         try:
-            digits = int(params[0])
-        except ValueError:
+            ignore_id = None
+            if len(params) > 2 and params[2].startswith('ignore:'):
+                ignore_field = params[2].split(':')[1]
+                ignore_id = self.get_field_value(ignore_field) 
+            return self.validator.db_manager.is_unique(table, column, value, ignore_id)
+        except Exception as e:
+            print(f"Database error in UniqueRule: {e}")
             return False
-            
-        return value.isdigit() and len(value) == digits
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be {params[0]} digits."
+        return f"The :attribute has already been taken."
 
-class DigitsBetweenRule(ValidationRule):
+class ExistsRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2 or not isinstance(value, str):
+        if not params or not hasattr(self.validator, 'db_manager') or not self.validator.db_manager:
             return False
             
+        table = params[0]
+        column = field if len(params) == 1 else params[1]
+        
         try:
-            min_digits = int(params[0])
-            max_digits = int(params[1])
-        except ValueError:
+            return self.validator.db_manager.exists(table, column, value)
+        except Exception as e:
+            print(f"Database error in ExistsRule: {e}")
             return False
-            
-        return value.isdigit() and min_digits <= len(value) <= max_digits
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be between {params[0]} and {params[1]} digits."
+        return f"The selected :attribute is invalid."
+    
+class SameRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+        return value == self.get_field_value(params[0]) 
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute and {params[0]} must match."
 
-class MultipleOfRule(ValidationRule):
+class DifferentRule(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 str(value) != self.get_field_value(params[0]) 
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute and {params[0]} must be different."
+
+class InRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        allowed_values = self._parse_option_values(field, params)
+        return (str(value) in allowed_values or value in allowed_values)
+
+    def message(self, field: str, params: List[str]) -> str:
+        allowed_values = self._parse_option_values(field, params)
+        return f"The selected :attribute must be in : {', '.join(map(str, allowed_values))}"
+
+class NotInRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        not_allowed_values = self._parse_option_values(field, params)
+        return str(value) not in not_allowed_values
+    
+    def message(self, field: str, params: List[str]) -> str:
+        not_allowed_values = self._parse_option_values(field, params)
+        return f"The selected :attribute must be not in : {', '.join(map(str, not_allowed_values))}"
+    
+class EnumRule(Rule):
+    def __init__(self, *params):
+        super().__init__()
+        self._params: List[str] = list(params)
+        self.allowed_values = self._parse_option_values(None, self._params, raise_for_error=False)
+    
+    def exclude(self, *options):
+        except_values = self._parse_option_values(None, options, raise_for_error=False)
+        self.allowed_values = [value for value in self.allowed_values if value not in except_values]
+        return self
+    
+    def only(self, *options):
+        only_values = self._parse_option_values(None, options, raise_for_error=False)
+        self.allowed_values = [value for value in self.allowed_values if value in only_values]
+        return self
+    
+    def when(self, 
+            condition: bool, 
+            when_true: Callable[['EnumRule'], 'EnumRule'], 
+            when_false: Optional[Callable[['EnumRule'], 'EnumRule']] = None
+        ) -> 'EnumRule':
+        
+        if condition:
+            return when_true(self)
+        elif when_false:
+            return when_false(self)
+        return self
+    
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        return (str(value) in self.allowed_values or value in self.allowed_values)
+
+    def message(self, field: str, params: List[str]) -> str:
+        allowed_values = self._parse_option_values(field, self.allowed_values)
+        return f"The :attribute must be one of: {', '.join(map(str, allowed_values))}"
+    
+class ContainsRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
             return False
+            
+        for search_value in params:
+            if isinstance(value, str) and search_value in value:
+                return True
+                
+            if isinstance(value, (int, float)) and str(search_value) in str(value):
+                return True
+                
+            if isinstance(value, (list, tuple, set)) and search_value in value:
+                return True
+                
+            if isinstance(value, dict) and search_value in value.keys():
+                return True
+                
+        return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a multiple of {params[0]}."
+        if len(params) == 1:
+            return f"The {field} must contain {params[0]}"
+        
+        joined_params = ", ".join(params[:-1]) + f" or {params[-1]}"
+        return f"The {field} must contain at least one of: {joined_params}"

validator/rules/date.py

@@ -1,9 +1,10 @@
-from .base import ValidationRule
+from .base import Rule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 from datetime import datetime
+import zoneinfo
 from dateutil.parser import parse
 
-class DateRule(ValidationRule):
+class DateRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, str):
             return False
@@ -15,18 +16,17 @@ class DateRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name is not a valid date."
+        return f"The :attribute is not a valid date."
 
-class DateEqualsRule(ValidationRule):
+class DateEqualsRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params or not isinstance(value, str):
             return False
         
-        value = self.get_field_value(value, value)
-        
         try:
             date1 = parse(value)
             
+            params = list(params)
             params[0] = self.get_field_value(params[0], params[0])
             
             date2 = parse(params[0])
@@ -35,9 +35,9 @@ class DateEqualsRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be equal to {params[0]}."
+        return f"The :attribute must be equal to {params[0]}."
     
-class AfterRule(ValidationRule):
+class AfterRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params or len(params) < 1:
             return False
@@ -51,7 +51,8 @@ class AfterRule(ValidationRule):
             else:
                 return False
                 
-            # Parse comparison date
+            
+            params = list(params)# Parse comparison date
             params[0] = self.get_field_value(params[0], params[0])
             compare_date = parse(params[0])
             
@@ -61,13 +62,12 @@ class AfterRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be after {params[0]}"
+        return f"The :attribute must be after {params[0]}"
     
-class AfterOrEqualRule(ValidationRule):
+class AfterOrEqualRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params or len(params) < 1:
             return False
-        
         try:
             if isinstance(value, str):
                 date_value = parse(value)
@@ -76,18 +76,19 @@ class AfterOrEqualRule(ValidationRule):
             else:
                 return False
             
+            params = list(params)
             params[0] = self.get_field_value(params[0], params[0])
             compare_date = parse(params[0])
             
             return date_value >= compare_date
             
-        except (ValueError, TypeError):
+        except (ValueError, TypeError) as e:
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be after or equal to {params[0]}"
+        return f"The :attribute must be after or equal to {params[0]}"
     
-class BeforeRule(ValidationRule):
+class BeforeRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params or len(params) < 1:
             return False
@@ -102,6 +103,7 @@ class BeforeRule(ValidationRule):
             else:
                 return False
             
+            params = list(params)
             params[0] = self.get_field_value(params[0], params[0])    
             compare_date = parse(params[0])
             
@@ -111,9 +113,9 @@ class BeforeRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be before {params[0]}"
+        return f"The :attribute must be before {params[0]}"
     
-class BeforeOrEqualRule(ValidationRule):
+class BeforeOrEqualRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params or len(params) < 1:
             return False
@@ -128,6 +130,7 @@ class BeforeOrEqualRule(ValidationRule):
             else:
                 return False
             
+            params = list(params)
             params[0] = self.get_field_value(params[0], params[0])
             compare_date = parse(params[0])
             
@@ -137,9 +140,9 @@ class BeforeOrEqualRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be before or equal to {params[0]}"
+        return f"The :attribute must be before or equal to {params[0]}"
     
-class DateFormatRule(ValidationRule):
+class DateFormatRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params or len(params) < 1 or not isinstance(value, str):
             return False
@@ -151,4 +154,17 @@ class DateFormatRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must match the format {params[0]}"
+        return f"The :attribute must match the format {params[0]}"
+    
+class TimezoneRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str):
+            return False
+        try:
+            zoneinfo.ZoneInfo(value)
+            return True
+        except zoneinfo.ZoneInfoNotFoundError:
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be a valid timezone."