safeshield 1.4.11__py3-none-any.whl → 1.5.2__py3-none-any.whl

validator/rules/comparison.py

@@ -6,10 +6,9 @@ from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type, Callable
 # =============================================
 
 class MinRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
         try:
             min_val = float(params[0])
         except ValueError:
@@ -28,12 +27,20 @@ class MinRule(Rule):
     
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute must be at least :min."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':min': self._params[0],
+        }
+        
+        return replacements
 
 class MaxRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or len(params) < 1:
-            return False
-            
         try:
             max_val = float(params[0])
             
@@ -91,12 +98,20 @@ class MaxRule(Rule):
         if any(hasattr(value, attr) for attr in file_attrs):
             return f"File :attribute must not exceed :max bytes"
         return f"The :attribute must not exceed :max"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':max': self._params[0],
+        }
+        
+        return replacements
 
 class BetweenRule(Rule):
+    _count_parameter = 2
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) != 2:
-            return False
-            
         try:
             min_val = float(params[0])
             max_val = float(params[1])
@@ -135,14 +150,23 @@ class BetweenRule(Rule):
     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 :attribute must be between {params[0]} and {params[1]} bytes"
-        return f"The :attribute must be between {params[0]} and {params[1]}"
+            return f"File :attribute must be between :min and :max bytes"
+        return f"The :attribute must be between :min and :max"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':min': self._params[0],
+            ':max': self._params[1],
+        }
+        
+        return replacements
 
 class SizeRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or len(params) < 1:
-            return False
-            
         try:
             target_size = float(params[0])
             
@@ -181,19 +205,29 @@ class SizeRule(Rule):
     def message(self, field: str, params: List[str]) -> str:
         value = self.get_field_value(field)
         if value is None:
-            return f"The :attribute must be exactly {params[0]}"
+            return f"The :attribute must be exactly :size"
             
         # Check for file attributes
         file_attrs = ['content_length', 'size', 'fileno']
         if any(hasattr(value, attr) for attr in file_attrs):
-            return f"File :attribute must be exactly {params[0]} bytes"
+            return f"File :attribute must be exactly :size bytes"
             
-        return f"The :attribute must be exactly {params[0]}"
+        return f"The :attribute must be exactly :size"
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':size': self._params[0],
+        }
+        
+        return replacements
 
 class UniqueRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or not hasattr(self.validator, 'db_manager') or not self.validator.db_manager:
+        if not hasattr(self.validator, 'db_manager') or not self.validator.db_manager:
             return False
             
         table = params[0]
@@ -213,8 +247,10 @@ class UniqueRule(Rule):
         return f"The :attribute has already been taken."
 
 class ExistsRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or not hasattr(self.validator, 'db_manager') or not self.validator.db_manager:
+        if not hasattr(self.validator, 'db_manager') or not self.validator.db_manager:
             return False
             
         table = params[0]
@@ -230,15 +266,28 @@ class ExistsRule(Rule):
         return f"The selected :attribute is invalid."
     
 class SameRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
-        return value == self.get_field_value(params[0]) 
+        return value == self.get_field_value(params[0], None) 
     
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute and :other must match."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+        }
+        
+        return replacements
 
 class DifferentRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
@@ -247,26 +296,56 @@ class DifferentRule(Rule):
     
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute and :other must be different."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+        }
+        
+        return replacements
 
 class InRule(Rule):
+    _count_parameter = 1
+    
     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))}"
+        return f"The selected :attribute must be in : :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._get_display_name(self._params)),
+        }
+        
+        return replacements
 
 class NotInRule(Rule):
+    _count_parameter = 1
+    
     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
+        return not InRule.validate(self, field, value, params=params)
     
     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))}"
+        return f"The selected :attribute must be not in : :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._get_display_name(self._params)),
+        }
+        
+        return replacements
     
 class EnumRule(Rule):
+    _count_parameter = 1
+    
     def __init__(self, *params):
         super().__init__()
         self._params: List[str] = list(params)
@@ -299,13 +378,21 @@ class EnumRule(Rule):
 
     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))}"
+        return f"The :attribute must be one of: :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(map(str, self.allowed_values)),
+        }
+        
+        return replacements
     
 class ContainsRule(Rule):
+    _count_parameter = 1
+    
     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
@@ -322,8 +409,13 @@ class ContainsRule(Rule):
         return False
     
     def message(self, field: str, params: List[str]) -> str:
-        if len(params) == 1:
-            return f"The {field} must contain {params[0]}"
+        return f"The :attribute must contain at least one of: :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._params),
+        }
         
-        joined_params = ", ".join(params[:-1]) + f" or {params[-1]}"
-        return f"The {field} must contain at least one of: {joined_params}"
+        return replacements

validator/rules/date.py

@@ -19,12 +19,17 @@ class DateRule(Rule):
         return f"The :attribute is not a valid date."
 
 class DateEqualsRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or not isinstance(value, str):
-            return False
         
         try:
-            date1 = parse(value)
+            if isinstance(value, str):
+                date1 = parse(value)
+            elif isinstance(value, datetime):
+                date1 = value
+            else:
+                return False
             
             params = list(params)
             params[0] = self.get_field_value(params[0], params[0])
@@ -35,15 +40,22 @@ class DateEqualsRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be equal to {params[0]}."
+        return f"The :attribute must be equal to :value."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self.get_field_value(self._params[0], self._params[0])
+        }
+        
+        return replacements
     
 class AfterRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or len(params) < 1:
-            return False
-            
         try:
-            # Parse input date
             if isinstance(value, str):
                 date_value = parse(value)
             elif isinstance(value, datetime):
@@ -62,12 +74,21 @@ class AfterRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be after {params[0]}"
+        return f"The :attribute must be after :value"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self.get_field_value(self._params[0], self._params[0])
+        }
+        
+        return replacements
     
 class AfterOrEqualRule(Rule):
+    _count_parameter = 1
+    
     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)
@@ -86,13 +107,21 @@ class AfterOrEqualRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be after or equal to {params[0]}"
+        return f"The :attribute must be after or equal to :value"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self.get_field_value(self._params[0], self._params[0])
+        }
+        
+        return replacements
     
 class BeforeRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or len(params) < 1:
-            return False
-        
         value = self.get_field_value(value, value)
     
         try:
@@ -104,7 +133,7 @@ class BeforeRule(Rule):
                 return False
             
             params = list(params)
-            params[0] = self.get_field_value(params[0], params[0])    
+            params[0] = self.get_field_value(params[0], params[0])
             compare_date = parse(params[0])
             
             return date_value < compare_date
@@ -113,13 +142,21 @@ class BeforeRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be before {params[0]}"
+        return f"The :attribute must be before :value"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self.get_field_value(self._params[0], self._params[0])
+        }
+        
+        return replacements
     
 class BeforeOrEqualRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or len(params) < 1:
-            return False
-        
         value = self.get_field_value(value, value) 
         
         try:
@@ -140,13 +177,21 @@ class BeforeOrEqualRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be before or equal to {params[0]}"
+        return f"The :attribute must be before or equal to :value"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self.get_field_value(self._params[0], self._params[0])
+        }
+        
+        return replacements
     
 class DateFormatRule(Rule):
+    _count_parameter = 1
+    
     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
-        
         try:
             datetime.strptime(value, params[0])
             return True
@@ -154,12 +199,19 @@ class DateFormatRule(Rule):
             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 :format"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':format': self.get_field_value(self._params[0], self._params[0])
+        }
+        
+        return replacements
     
 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

validator/rules/files.py

@@ -34,7 +34,7 @@ class FileRule(Rule):
 class DimensionsRule(Rule):
     def __init__(self, *params):
         super().__init__(*params)
-        
+        self._count_parameter = 1
         self._constraints = {
             'min_width': 0,
             'min_height': 0,
@@ -44,7 +44,7 @@ class DimensionsRule(Rule):
             'height': None,
             'ratio': None
         }
-        
+
     def maxWidth(self, value: int) -> 'DimensionsRule':
         self._constraints['width'] = None
         self._constraints['max_width'] = value
@@ -195,11 +195,25 @@ class DimensionsRule(Rule):
         
         return f"The :attribute image must satisfy: {', '.join(constraints)}"
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':width': self._constraints['width'],
+            ':min_width': self._constraints['min_width'],
+            ':max_width': self._constraints['max_width'],
+            ':height': self._constraints['height'],
+            ':min_height': self._constraints['min_height'],
+            ':max_height': self._constraints['max_height'],
+            ':ratio': self._constraints['ratio'],
+        }
+        
+        return replacements
+    
 class ExtensionsRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
         filename = (
             value.filename if hasattr(value, 'filename') 
             else str(value)
@@ -212,7 +226,16 @@ class ExtensionsRule(Rule):
         return ext in [e.lower().strip() for e in params]
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"File :attribute must have one of these extensions: {', '.join(params)}"
+        return f"File :attribute must have one of these extensions: :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._params)
+        }
+        
+        return replacements
     
 class ImageRule(Rule):
     VALID_EXTENSIONS = {'jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'}
@@ -243,10 +266,9 @@ class ImageRule(Rule):
         return f"The :attribute must be a valid image file (JPEG, PNG, GIF, BMP, or WebP)"
     
 class MimeTypesRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
         # Check from content_type attribute
         if hasattr(value, 'content_type'):
             return value.content_type in params
@@ -258,10 +280,20 @@ class MimeTypesRule(Rule):
         return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"File :attribute must be one of these types: {', '.join(params)}"
+        return f"File :attribute must be one of these types: :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._params)
+        }
+        
+        return replacements
     
 class MimeTypeByExtensionRule(Rule):
     _name = 'mimes'
+    _count_parameter = 1
     
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if value is None or not hasattr(value, 'filename'):
@@ -276,4 +308,13 @@ class MimeTypeByExtensionRule(Rule):
         return mime_type in params if mime_type else False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be one of these types: {', '.join(params)}"
+        return f"The :attribute must be one of these types: :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._params)
+        }
+        
+        return replacements

validator/rules/format.py

@@ -122,6 +122,15 @@ class EmailRule(Rule):
             base_msg += " (Unicode allowed)"
             
         return f"{base_msg}."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._params if self._params else ['rfc']),
+        }
+        
+        return replacements
 
 class UrlRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool: