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

validator/rules/conditional.py

@@ -1,6 +1,7 @@
 from .base import ValidationRule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 from enum import Enum
+from .basic import RequiredRule, ProhibitedRule, PresentRule, MissingRule, ExcludeRule
 import re
 import inspect
 from collections.abc import Iterable
@@ -9,7 +10,7 @@ from collections.abc import Iterable
 # CONDITIONAL VALIDATION RULES
 # =============================================
 
-class RequiredIfRule(ValidationRule):
+class RequiredIfRule(RequiredRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if len(params) < 2 or len(params) % 2 != 0:
             return True
@@ -22,30 +23,30 @@ class RequiredIfRule(ValidationRule):
                 continue
                 
             actual_value = self.get_field_value(other_field, '')
+            
             if actual_value == expected_value:
                 condition_met = True
                 break
-        
+            
         if not condition_met:
             return True
-            
-        return not self.is_empty(value)
+        
+        return super().validate(field, value, params)
     
-    def message(self, field: str, params: List[str]) -> str:
-        valid_conditions = []
-        if len(params) >= 2 and len(params) % 2 == 0:
-            valid_conditions = [
-                f"{params[i]} = {params[i+1]}" 
-                for i in range(0, len(params), 2) 
-                if params[i] and params[i+1] is not None
-            ]
+class RequiredUnlessRule(RequiredRule):
+    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 not valid_conditions:
-            return f"Invalid required_if rule configuration for {field}"
+        if actual_value == other_value:
+            return True
             
-        return f"The :name field is required when any of these are true: {', '.join(valid_conditions)}"
+        return super().validate(field, value, params)
     
-class RequiredAllIfRule(ValidationRule):
+class RequiredAllIfRule(RequiredRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if len(params) < 2:
             return False
@@ -60,77 +61,9 @@ class RequiredAllIfRule(ValidationRule):
         if not all_conditions_met:
             return True
             
-        return not self.is_empty(value)
-    
-    def message(self, field: str, params: List[str]) -> str:
-        conditions = " AND ".join(f"{f} = {v}" for f, v in zip(params[::2], params[1::2]))
-        return f"The :name field is required when ALL conditions are met: {conditions}"
-
-class RequiredUnlessRule(ValidationRule):
-    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 not self.is_empty(value)
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required unless {params[0]} is {params[1]}."
-
-class RequiredWithRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
-        if any(f in self.validator.data for f in params):
-            return not self.is_empty(value)
-        return True
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required when {', '.join(params)} is present."
-
-class RequiredWithAllRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
-        if all(f in self.validator.data for f in params):
-            return not self.is_empty(value)
-        return True
+        return super().validate(field, value, params)
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required when all of {', '.join(params)} are present."
-
-class RequiredWithoutRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
-        if any(f not in self.validator.data for f in params):
-            return not self.is_empty(value)
-        return True
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required when {', '.join(params)} is not present."
-
-class RequiredWithoutAllRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
-        if all(f not in self.validator.data for f in params):
-            return not self.is_empty(value)
-        return True
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required when none of {', '.join(params)} are present."
-
-class ProhibitedIfRule(ValidationRule):
+class ProhibitedIfRule(ProhibitedRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if len(params) < 2:
             return False
@@ -141,12 +74,9 @@ class ProhibitedIfRule(ValidationRule):
         if actual_value != other_value:
             return True
             
-        return self.is_empty(value)
+        return super().validate(field, value, params)
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is prohibited when {params[0]} is {params[1]}."
-
-class ProhibitedUnlessRule(ValidationRule):
+class ProhibitedUnlessRule(ProhibitedRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if len(params) < 2:
             return False
@@ -157,176 +87,79 @@ class ProhibitedUnlessRule(ValidationRule):
         if actual_value == other_value:
             return True
             
-        return self.is_empty(value)
+        return super().validate(field, value, params)
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is prohibited unless {params[0]} is {params[1]}."
-
-class FilledIfRule(ValidationRule):
+class PresentIfRule(PresentRule):
     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 value not in ('', None)
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be filled when {params[0]} is {params[1]}."
-
-class RegexRule(ValidationRule):
-    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 :name format is invalid."
-
-class NotRegexRule(ValidationRule):
-    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 :name format is invalid."
-
-class InRule(ValidationRule):
-    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 :name must be in : {', '.join(map(str, allowed_values))}"
-
-class NotInRule(ValidationRule):
-    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 :name must be not in : {', '.join(map(str, not_allowed_values))}"
+        if self.get_field_value(other_field, None) == other_value:
+            return super().validate(field, value, params)
+        return True
     
-class EnumRule(ValidationRule):
-    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 :name must be one of: {', '.join(map(str, allowed_values))}"
-
-class UniqueRule(ValidationRule):
+class PresentUnlessRule(PresentRule):
     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 len(params) < 2:
             return False
-            
-        table = params[0]
-        column = field if len(params) == 1 else params[1]
+        other_field, other_value = params[0], params[1]
         
-        try:
-            # Optional: handle ignore case (id)
-            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
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name has already been taken."
-
-class ExistsRule(ValidationRule):
-    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:
-            return False
-            
-        table = params[0]
-        column = field if len(params) == 1 else params[1]
+        if self.get_field_value(other_field, None) != other_value:
+            return super().validate(field, value, params)
         
-        try:
-            return self.validator.db_manager.exists(table, column, value)
-        except Exception as e:
-            print(f"Database error in ExistsRule: {e}")
-            return False
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The selected :name is invalid."
-
-class ConfirmedRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        confirmation_field = f"{field}_confirmation"
+        return True
         
-        return value == self.get_field_value(confirmation_field, '') 
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name confirmation does not match."
-
-class SameRule(ValidationRule):
+class MissingIfRule(MissingRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
+        if len(params) < 2:
             return False
-        return value == self.get_field_value(params[0]) 
+        other_field, other_value = params[0], params[1]
+        
+        if self.get_field_value(other_field, None) == other_value:
+            return super().validate(field, value, params)
+        
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name and {params[0]} must match."
-
-class DifferentRule(ValidationRule):
+class MissingUnlessRule(MissingRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
+        if len(params) < 2:
             return False
-        return value != self.get_field_value(params[0]) 
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name and {params[0]} must be different."
+        other_field, other_value = params[0], params[1]
+        if self.get_field_value(other_field, None) != other_value:
+            return super().validate(field, value, params)
 
-class AcceptedRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if isinstance(value, str):
-            return value.lower() in ['yes', 'on', '1', 'true']
-        if isinstance(value, int):
-            return value == 1
-        if isinstance(value, bool):
-            return value
-        return False
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be accepted."
-
-class DeclinedRule(ValidationRule):
+class ExcludeIfRule(ExcludeRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if isinstance(value, str):
-            return value.lower() in ['no', 'off', '0', 'false']
-        if isinstance(value, int):
-            return value == 0
-        if isinstance(value, bool):
-            return not value
-        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 all_conditions_met:
+            return super().validate(field, value, params)
+        return True
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be declined."
-
+        return f"The :attribute field is excluded when {params[0]} is {params[1]}."
 
-class BailRule(ValidationRule):
+class ExcludeUnlessRule(ExcludeRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        self.validator._stop_on_first_failure = True
+        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 super().validate(field, value, params)
+            
         return True
-    
+            
     def message(self, field: str, params: List[str]) -> str:
-        return ""
+        return f"The :attribute field is excluded unless {params[0]} is {params[1]}."

validator/rules/date.py

@@ -15,7 +15,7 @@ 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):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -35,7 +35,7 @@ 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):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -61,7 +61,7 @@ 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):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -85,7 +85,7 @@ class AfterOrEqualRule(ValidationRule):
             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):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -111,7 +111,7 @@ 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):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -137,7 +137,7 @@ 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):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -151,4 +151,4 @@ 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]}"

validator/rules/files.py

@@ -28,7 +28,7 @@ class FileRule(ValidationRule):
         return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The {field} must be a valid file"
+        return f"The :attribute must be a valid file"
 
 class DimensionsRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -99,7 +99,7 @@ class DimensionsRule(ValidationRule):
         if max_rules:
             messages.append(f"maximum {max_rules[0][4:]}")
             
-        return f"Image {field} dimensions must be {' and '.join(messages)}"
+        return f"Image :attribute dimensions must be {' and '.join(messages)}"
     
 class ExtensionsRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -118,7 +118,7 @@ class ExtensionsRule(ValidationRule):
         return ext in [e.lower().strip() for e in params]
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"File {field} must have one of these extensions: {', '.join(params)}"
+        return f"File :attribute must have one of these extensions: {', '.join(params)}"
     
 class ImageRule(ValidationRule):
     VALID_EXTENSIONS = {'jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'}
@@ -146,7 +146,7 @@ class ImageRule(ValidationRule):
         return True
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The {field} must be a valid image file (JPEG, PNG, GIF, BMP, or WebP)"
+        return f"The :attribute must be a valid image file (JPEG, PNG, GIF, BMP, or WebP)"
     
 class MimeTypesRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -164,4 +164,4 @@ class MimeTypesRule(ValidationRule):
         return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"File {field} must be one of these types: {', '.join(params)}"
+        return f"File :attribute must be one of these types: {', '.join(params)}"

validator/rules/format.py

@@ -17,7 +17,7 @@ class EmailRule(ValidationRule):
         return bool(re.match(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$", value))
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a valid email address."
+        return f"The :attribute must be a valid email address."
 
 class UrlRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -32,7 +32,7 @@ class UrlRule(ValidationRule):
         ))
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a valid URL."
+        return f"The :attribute must be a valid URL."
 
 class JsonRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -45,7 +45,7 @@ class JsonRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a valid JSON string."
+        return f"The :attribute must be a valid JSON string."
 
 class UuidRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -58,7 +58,7 @@ class UuidRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a valid UUID."
+        return f"The :attribute must be a valid UUID."
 
 class UlidRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -67,7 +67,7 @@ class UlidRule(ValidationRule):
         return bool(re.match(r'^[0-9A-HJKMNP-TV-Z]{26}$', value))
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a valid ULID."
+        return f"The :attribute must be a valid ULID."
 
 class IpRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -80,7 +80,7 @@ class IpRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a valid IP address."
+        return f"The :attribute must be a valid IP address."
 
 class TimezoneRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -93,7 +93,7 @@ class TimezoneRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a valid timezone."
+        return f"The :attribute must be a valid timezone."
 
 class HexRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -102,4 +102,4 @@ class HexRule(ValidationRule):
         return bool(re.match(r'^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$', value))
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a valid hexadecimal color code."
+        return f"The :attribute must be a valid hexadecimal color code."

validator/rules/string.py

@@ -6,54 +6,47 @@ import re
 # STRING VALIDATION RULES
 # =============================================
 
-class StringRule(ValidationRule):
-    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."
-
 class AlphaRule(ValidationRule):
     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):
     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):
     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):
     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):
     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):
     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):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -62,7 +55,7 @@ class StartsWithRule(ValidationRule):
         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 EndsWithRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -71,4 +64,4 @@ class EndsWithRule(ValidationRule):
         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)}."

validator/rules/type.py

@@ -6,6 +6,13 @@ from datetime import datetime
 # TYPE DATA VALIDATION RULES
 # =============================================
 
+class StringRule(ValidationRule):
+    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 :attribute must be a string."
+
 class NumericRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if isinstance(value, (int, float)):
@@ -15,7 +22,7 @@ class NumericRule(ValidationRule):
         return value.replace('.', '', 1).isdigit()
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a number."
+        return f"The :attribute must be a number."
 
 class IntegerRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -26,7 +33,7 @@ class IntegerRule(ValidationRule):
         return value.isdigit()
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be an integer."
+        return f"The :attribute must be an integer."
 
 class BooleanRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -39,4 +46,4 @@ class BooleanRule(ValidationRule):
         return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be true or false."
+        return f"The :attribute field must be true or false."