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

validator/rules/boolean.py

@@ -0,0 +1,157 @@
+from .base import Rule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+
+class BooleanRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if isinstance(value, bool):
+            return True
+        if isinstance(value, str):
+            return value.lower() in ['true', 'false', '1', '0', 'yes', 'no', 'on', 'off']
+        if isinstance(value, int):
+            return value in [0, 1]
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute field must be true or false."
+    
+class AcceptedRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        value = self.get_field_value(value, value)
+        
+        if isinstance(value, str):
+            return value.lower() in ['yes', 'on', '1', 1, True, 'true', 'True']
+        if isinstance(value, int):
+            return value == 1
+        if isinstance(value, bool):
+            return value
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be accepted."
+
+class DeclinedRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        value = self.get_field_value(value, value)
+        
+        if isinstance(value, str):
+            return value.lower() in ['no', 'off', '0', 0, False, 'false', 'False']
+        if isinstance(value, int):
+            return value == 0
+        if isinstance(value, bool):
+            return not value
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be declined."
+    
+class AcceptedIfRule(AcceptedRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        condition_met = False
+
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and isinstance(params[0], bool):
+            condition_met = params[0]
+        else:  
+            conditions = list(zip(params[::2], params[1::2]))
+            
+            for other_field, expected_value in conditions:
+                if not other_field or expected_value is None:
+                    continue
+                    
+                actual_value = self.get_field_value(other_field, '')
+                
+                if actual_value == expected_value:
+                    condition_met = True
+                    break
+            
+        if condition_met:
+            return super().validate(field, value, params)
+        
+        return True
+    
+class AcceptedUnlessRule(AcceptedRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 2:
+            return False
+            
+        other_field, other_value = params[0], params[1]
+        actual_value = self.get_field_value(other_field, '') 
+        
+        if actual_value == other_value:
+            return True
+            
+        return super().validate(field, value, params)
+    
+class AcceptedAllIfRule(AcceptedRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 2:
+            return False
+            
+        conditions = [(f.strip(), v.strip()) for f, v in zip(params[::2], params[1::2])]
+        
+        all_conditions_met = all(
+            self.get_field_value(f) == v 
+            for f, v in conditions
+        )
+        
+        if not all_conditions_met:
+            return True
+            
+        return super().validate(field, value, params)
+    
+class DeclinedIfRule(DeclinedRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        condition_met = False
+                
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and isinstance(params[0], bool):
+            condition_met = params[0]
+        else:  
+            conditions = list(zip(params[::2], params[1::2]))
+            
+            for other_field, expected_value in conditions:
+                if not other_field or expected_value is None:
+                    continue
+                    
+                actual_value = self.get_field_value(other_field, '')
+                
+                if actual_value == expected_value:
+                    condition_met = True
+                    break
+                
+            if condition_met:
+                return super().validate(field, value, params)
+            
+        return True
+    
+class DeclinedUnlessRule(DeclinedRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 2:
+            return False
+            
+        other_field, other_value = params[0], params[1]
+        actual_value = self.get_field_value(other_field, '') 
+        
+        if actual_value == other_value:
+            return True
+            
+        return super().validate(field, value, params)
+    
+class DeclinedAllIfRule(DeclinedRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 2:
+            return False
+            
+        conditions = [(f.strip(), v.strip()) for f, v in zip(params[::2], params[1::2])]
+        
+        all_conditions_met = all(
+            self.get_field_value(f) == v 
+            for f, v in conditions
+        )
+        
+        if not all_conditions_met:
+            return True
+            
+        return super().validate(field, value, params)

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
@@ -29,7 +29,7 @@ class MinRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         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
@@ -93,7 +93,7 @@ class MaxRule(ValidationRule):
             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
@@ -139,7 +139,7 @@ class BetweenRule(ValidationRule):
             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
@@ -191,50 +191,140 @@ class SizeRule(ValidationRule):
             
         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 :attribute 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 :attribute 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 :attribute 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
@@ -17,16 +18,15 @@ class DateRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         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])
@@ -37,7 +37,7 @@ class DateEqualsRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         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])
             
@@ -63,11 +64,10 @@ class AfterRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         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 :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])
             
@@ -113,7 +115,7 @@ class BeforeRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         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])
             
@@ -139,7 +142,7 @@ class BeforeOrEqualRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         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 :attribute 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."