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

validator/rules/numeric.py

@@ -25,10 +25,9 @@ class IntegerRule(Rule):
         return f"The :attribute must be an integer."
 
 class DigitsRule(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:
             digits = int(params[0])
         except ValueError:
@@ -37,13 +36,21 @@ class DigitsRule(Rule):
         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 must be :value digits."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self._params[0],
+        }
+        
+        return replacements
 
 class DigitsBetweenRule(Rule):
+    _count_parameter = 2
+    
     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])
@@ -53,7 +60,17 @@ class DigitsBetweenRule(Rule):
         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 :attribute must be between :min and :max digits."
+    
+    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 DecimalRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -68,11 +85,9 @@ class DecimalRule(Rule):
 
 class GreaterThanRule(Rule):
     _name = 'gt'
+    _count_parameter = 1
     
     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))
@@ -81,15 +96,22 @@ class GreaterThanRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be greater than {params[0]}."
+        return f"The :attribute must be greater than :value."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self._params[0],
+        }
+        
+        return replacements
 
 class GreaterThanOrEqualRule(Rule):
     _name = 'gte'
+    _count_parameter = 1
     
     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))
@@ -98,15 +120,22 @@ class GreaterThanOrEqualRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be greater than or equal to {params[0]}."
+        return f"The :attribute must be greater than or equal to :value."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self._params[0],
+        }
+        
+        return replacements
 
 class LessThanRule(Rule):
     _name = 'lt'
+    _count_parameter = 1
     
     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))
@@ -115,15 +144,22 @@ class LessThanRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be less than {params[0]}."
+        return f"The :attribute must be less than :value."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self._params[0],
+        }
+        
+        return replacements
 
 class LessThanOrEqualRule(Rule):
     _name = 'lte'
+    _count_parameter = 1
     
     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))
@@ -132,13 +168,21 @@ class LessThanOrEqualRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be less than or equal to {params[0]}."
+        return f"The :attribute must be less than or equal to :value."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self._params[0],
+        }
+        
+        return replacements
 
 class MaxDigitsRule(Rule):
+    _count_parameter = 1
+    
     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))
@@ -150,13 +194,21 @@ class MaxDigitsRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must not exceed {params[0]} digits."
+        return f"The :attribute must not exceed :value digits."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self._params[0],
+        }
+        
+        return replacements
 
 class MinDigitsRule(Rule):
+    _count_parameter = 1
+    
     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))
@@ -168,13 +220,21 @@ class MinDigitsRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must have at least {params[0]} digits."
+        return f"The :attribute must have at least :value digits."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self._params[0],
+        }
+        
+        return replacements
 
 class MultipleOfRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
         try:
             divisor = float(params[0])
             if divisor == 0:
@@ -185,4 +245,13 @@ class MultipleOfRule(Rule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be a multiple of {params[0]}."
+        return f"The :attribute must be a multiple of :value."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self._params[0]
+        }
+        
+        return replacements

validator/rules/string.py

@@ -56,40 +56,84 @@ class AsciiRule(Rule):
         return f"The :attribute must only contain ASCII characters."
     
 class StartsWithRule(Rule):
+    _count_parameter = 1
+    
     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 :attribute must start with one of the following: {', '.join(params)}."
+        return f"The :attribute must start with one of the following: :values."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._params),
+        }
+        
+        return replacements
     
 class DoesntStartWithRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not isinstance(value, str) or not params:
+        if not isinstance(value, str):
             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)}"
+        return f"The :attribute must not start with any of: :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._params),
+        }
+        
+        return replacements
 
 class EndsWithRule(Rule):
+    _count_parameter = 1
+    
     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 :attribute must end with one of the following: {', '.join(params)}."
+        return f"The :attribute must end with one of the following: :values."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._params),
+        }
+        
+        return replacements
     
 class DoesntEndWithRule(Rule):
+    _count_parameter = 1
+    
     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)}"
+        return f"The :attribute must not end with any of: :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._params),
+        }
+        
+        return replacements
     
 class ConfirmedRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -101,8 +145,10 @@ class ConfirmedRule(Rule):
         return f"The :attribute confirmation does not match."
     
 class RegexRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or not isinstance(value, str):
+        if not isinstance(value, str):
             return False
         try:
             return bool(re.fullmatch(params[0], value))
@@ -113,10 +159,9 @@ class RegexRule(Rule):
         return f"The :attribute format is invalid."
 
 class NotRegexRule(Rule):
+    _count_parameter = 1
+    
     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: