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

validator/rules/files.py

@@ -1,7 +1,8 @@
-from .base import ValidationRule
+from .base import Rule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+import mimetypes
 
-class FileRule(ValidationRule):
+class FileRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         # 1. Cek file object framework (Flask/Werkzeug/FastAPI)
         if (hasattr(value, 'filename') and 
@@ -30,78 +31,171 @@ class FileRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute must be a valid file"
 
-class DimensionsRule(ValidationRule):
+class DimensionsRule(Rule):
+    def __init__(self, *params):
+        super().__init__(*params)
+        
+        self._constraints = {
+            'min_width': 0,
+            'min_height': 0,
+            'max_width': float('inf'),
+            'max_height': float('inf'),
+            'width': None,
+            'height': None,
+            'ratio': None
+        }
+        
+    def maxWidth(self, value: int) -> 'DimensionsRule':
+        self._constraints['width'] = None
+        self._constraints['max_width'] = value
+        return self
+
+    def maxHeight(self, value: int) -> 'DimensionsRule':
+        self._constraints['height'] = None
+        self._constraints['max_height'] = value
+        return self
+
+    def ratio(self, value: float) -> 'DimensionsRule':
+        self._constraints['ratio'] = value
+        return self
+
+    def minWidth(self, value: int) -> 'DimensionsRule':
+        self._constraints['width'] = None
+        self._constraints['min_width'] = value
+        return self
+
+    def minHeight(self, value: int) -> 'DimensionsRule':
+        self._constraints['height'] = None
+        self._constraints['min_height'] = value
+        return self
+    
+    def _validate_constraint_logic(self):
+        if self._constraints['width'] is not None:
+            if (self._constraints['min_width'] > 0 or 
+                self._constraints['max_width'] < float('inf')):
+                raise ValueError("Cannot specify both exact width and min/max width")
+
+        if self._constraints['max_width'] < self._constraints['min_width']:
+            raise ValueError(f"max_width ({self._constraints['max_width']}) "
+                f"cannot be less than min_width ({self._constraints['min_width']})")
+
+        if self._constraints['height'] is not None:
+            if (self._constraints['min_height'] > 0 or 
+                self._constraints['max_height'] < float('inf')):
+                raise ValueError("Cannot specify both exact height and min/max height")
+
+        if self._constraints['max_height'] < self._constraints['min_height']:
+            raise ValueError(f"max_height ({self._constraints['max_height']}) "
+                f"cannot be less than min_height ({self._constraints['min_height']})")
+        
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        self._validate_constraint_logic()
         try:
-            from PIL import Image
-            import io
-
-            # 1. Parse dimension rules
-            min_width = min_height = 0
-            max_width = max_height = float('inf')
-            
+            # 2. Parse parameters
             for param in params:
-                try:
-                    if param.startswith('min:'):
-                        min_width, min_height = map(int, param[4:].split('x'))
-                    elif param.startswith('max:'):
-                        max_width, max_height = map(int, param[4:].split('x'))
-                    else:
-                        exact_width, exact_height = map(int, param.split('x'))
-                        min_width = max_width = exact_width
-                        min_height = max_height = exact_height
-                except (ValueError, IndexError):
-                    continue
-
-            # 2. Load image with proper handling
-            img = None
-            try:
-                # Case 1: File-like object (Flask/Werkzeug/FastAPI)
-                if hasattr(value, 'read'):
-                    value.seek(0)  # Important for rewinding
-                    img = Image.open(value)
-                    value.seek(0)  # Reset after reading
-                
-                # Case 2: Bytes data
-                elif isinstance(value, bytes):
-                    img = Image.open(io.BytesIO(value))
+                # Format Laravel: min_width=100
+                if '=' in param:
+                    key, val = param.split('=', 1)
+                    if key in self._constraints:
+                        try:
+                            self._constraints[key] = float(val)
+                        except ValueError:
+                            continue
                 
-                # Case 3: File path (string)
-                elif isinstance(value, str) and value.lower().endswith(('.jpg', '.jpeg', '.png', '.gif')):
-                    img = Image.open(value)
+                # Format legacy: 100x200
+                elif 'x' in param:
+                    try:
+                        width, height = map(int, param.split('x'))
+                        self._constraints['width'] = width
+                        self._constraints['height'] = height
+                    except ValueError:
+                        continue
                 
-                if img is None:
-                    return False
-
-                # 3. Validate dimensions
-                width, height = img.size
-                return (min_width <= width <= max_width and 
-                        min_height <= height <= max_height)
+                # Format ratio: 3/2
+                elif '/' in param:
+                    try:
+                        self._constraints['ratio'] = param
+                    except ValueError:
+                        continue
 
-            except (IOError, OSError, AttributeError) as e:
-                print(f"Image loading failed: {str(e)}")
+            # 3. Load image
+            img = self._load_image(value)
+            if not img:
                 return False
 
+            width, height = img.size
+            actual_ratio = round(width / height, 2)
+
+            # 4. Validate _constraints
+            checks = [
+                (self._constraints['width'] is None or width == self._constraints['width']),
+                (self._constraints['height'] is None or height == self._constraints['height']),
+                width >= self._constraints['min_width'],
+                height >= self._constraints['min_height'],
+                width <= self._constraints['max_width'],
+                height <= self._constraints['max_height'],
+                self._check_ratio(self._constraints['ratio'], actual_ratio)
+            ]
+            
+            return all(checks)
+
         except Exception as e:
-            print(f"Unexpected error in dimension validation: {str(e)}")
+            print(f"Dimension validation error: {str(e)}")
             return False
-    
+
+    def _load_image(self, value):
+        """Helper to load image from different sources"""
+        try:
+            from PIL import Image
+            import io
+            
+            if hasattr(value, 'read'):  # File-like object
+                value.seek(0)
+                img = Image.open(value)
+                value.seek(0)
+                return img
+            elif isinstance(value, bytes):  # Bytes
+                return Image.open(io.BytesIO(value))
+            elif isinstance(value, str):  # File path
+                if value.lower().endswith(('.jpg', '.jpeg', '.png', '.gif')):
+                    return Image.open(value)
+            return None
+        except:
+            return None
+
+    def _check_ratio(self, ratio_constraint, actual_ratio):
+        """Validate aspect ratio"""
+        if not ratio_constraint:
+            return True
+            
+        try:
+            numerator, denominator = map(float, ratio_constraint.split('/'))
+            expected_ratio = round(numerator / denominator, 2)
+            return actual_ratio == expected_ratio
+        except:
+            return False
+
     def message(self, field: str, params: List[str]) -> str:
-        min_rules = [p for p in params if p.startswith('min:')]
-        max_rules = [p for p in params if p.startswith('max:')]
-        exact_rules = [p for p in params if ':' not in p]
+        constraints = []
         
-        messages = []
-        if exact_rules:
-            messages.append(f"exactly {exact_rules[0]}")
-        if min_rules:
-            messages.append(f"minimum {min_rules[0][4:]}")
-        if max_rules:
-            messages.append(f"maximum {max_rules[0][4:]}")
-            
-        return f"Image :attribute dimensions must be {' and '.join(messages)}"
+        if self._constraints['width'] is not None:
+            constraints.append(f"width={self._constraints['width']}")
+        if self._constraints['height'] is not None:
+            constraints.append(f"height={self._constraints['height']}")
+        if self._constraints['min_width'] > 0:
+            constraints.append(f"min_width={self._constraints['min_width']}")
+        if self._constraints['max_width'] < float('inf'):
+            constraints.append(f"max_width={self._constraints['max_width']}")
+        if self._constraints['min_height'] > 0:
+            constraints.append(f"min_height={self._constraints['min_height']}")
+        if self._constraints['max_height'] < float('inf'):
+            constraints.append(f"max_height={self._constraints['max_height']}")
+        if self._constraints['ratio'] is not None:
+            constraints.append(f"ratio={self._constraints['ratio']:.2f}")
+        
+        return f"The :attribute image must satisfy: {', '.join(constraints)}"
     
-class ExtensionsRule(ValidationRule):
+class ExtensionsRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
@@ -120,7 +214,7 @@ class ExtensionsRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         return f"File :attribute must have one of these extensions: {', '.join(params)}"
     
-class ImageRule(ValidationRule):
+class ImageRule(Rule):
     VALID_EXTENSIONS = {'jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'}
     VALID_MIME_TYPES = {
         'image/jpeg', 'image/png', 
@@ -148,7 +242,7 @@ class ImageRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute must be a valid image file (JPEG, PNG, GIF, BMP, or WebP)"
     
-class MimeTypesRule(ValidationRule):
+class MimeTypesRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
@@ -164,4 +258,22 @@ class MimeTypesRule(ValidationRule):
         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: {', '.join(params)}"
+    
+class MimeTypeByExtensionRule(Rule):
+    _name = 'mimes'
+    
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if value is None or not hasattr(value, 'filename'):
+            return False
+            
+        mimetypes.init()
+        
+        extension = value.filename.split('.')[-1].lower()
+        
+        mime_type = mimetypes.guess_type(f"file.{extension}")[0]
+        
+        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)}"

validator/rules/format.py

@@ -1,25 +1,129 @@
-from .base import ValidationRule
+from .base import Rule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 import re
-import zoneinfo
 import ipaddress
 import json
 import uuid
+import dns.resolver
+import idna
 
 # =============================================
 # FORMAT VALIDATION RULES
 # =============================================
 
-class EmailRule(ValidationRule):
+class EmailRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        """
+        Available params:
+        - rfc: RFCValidation (default)
+        - strict: NoRFCWarningsValidation
+        - dns: DNSCheckValidation
+        - spoof: SpoofCheckValidation
+        - filter: FilterEmailValidation
+        - filter_unicode: FilterEmailValidation::unicode()
+        """
+        
         if not isinstance(value, str):
             return False
-        return bool(re.match(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$", value))
-    
+
+        # Default to RFC validation if no params specified
+        validation_types = params if params else ['rfc']
+
+        # Apply all requested validations
+        for validation in validation_types:
+            if validation == 'rfc' and not self._validate_rfc(value):
+                return False
+            elif validation == 'strict' and not self._validate_strict(value):
+                return False
+            elif validation == 'dns' and not self._validate_dns(value):
+                return False
+            elif validation == 'spoof' and not self._validate_spoof(value):
+                return False
+            elif validation == 'filter' and not self._validate_filter(value):
+                return False
+            elif validation == 'filter_unicode' and not self._validate_filter_unicode(value):
+                return False
+
+        return True
+
+    def _validate_rfc(self, email: str) -> bool:
+        """Strict RFC-compliant email validation (single-line version)"""
+        return bool(re.match(
+            r"^(?!(\.|\.\.))[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@(?=.{1,255}$)[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*\.[a-zA-Z]{2,}$", 
+            email
+        ))
+
+    def _validate_strict(self, email: str) -> bool:
+        """Strict RFC validation (no warnings)"""
+        if not self._validate_rfc(email):
+            return False
+        
+        # No leading/trailing dots
+        if email.startswith('.') or email.endswith('.'):
+            return False
+            
+        # No consecutive dots
+        if '..' in email.split('@')[0]:
+            return False
+            
+        return True
+
+    def _validate_dns(self, email: str) -> bool:
+        """DNS MX record validation"""
+        try:
+            domain = email.split('@')[-1]
+            return bool(dns.resolver.resolve(domain, 'MX'))
+        except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN, 
+            dns.resolver.NoNameservers, dns.exception.DNSException):
+            return False
+
+    def _validate_spoof(self, email: str) -> bool:
+        """Spoof/homograph detection"""
+        try:
+            domain_part = email.split('@')[-1]
+            ascii_domain = idna.encode(domain_part).decode('ascii')
+            
+            # Check for homographs
+            if domain_part != ascii_domain:
+                return False
+                
+            # Check for deceptive characters
+            return not any(ord(char) > 127 for char in email)
+        except idna.IDNAError:
+            return False
+
+    def _validate_filter(self, email: str) -> bool:
+        """PHP filter_var compatible validation"""
+        return bool(re.match(
+            r"^(?!(\.|\.\.))[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$",
+            email
+        ))
+
+    def _validate_filter_unicode(self, email: str) -> bool:
+        """PHP filter_var with Unicode support"""
+        return bool(re.match(
+            r"^(?!(\.|\.\.))[\w.!#$%&'*+/=?^_`{|}~-]+@[\w-]+(?:\.[\w-]+)*$",
+            email,
+            re.UNICODE
+        ))
+
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be a valid email address."
+        base_msg = "The :attribute must be a valid email address"
+        
+        if 'strict' in params:
+            base_msg += " (strict RFC compliance)"
+        if 'dns' in params:
+            base_msg += " with valid DNS records"
+        if 'spoof' in params:
+            base_msg += " without spoofed characters"
+        if 'filter' in params:
+            base_msg += " (PHP filter compatible)"
+        if 'filter_unicode' in params:
+            base_msg += " (Unicode allowed)"
+            
+        return f"{base_msg}."
 
-class UrlRule(ValidationRule):
+class UrlRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, str):
             return False
@@ -34,7 +138,7 @@ class UrlRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute must be a valid URL."
 
-class JsonRule(ValidationRule):
+class JsonRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, str):
             return False
@@ -47,7 +151,7 @@ class JsonRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute must be a valid JSON string."
 
-class UuidRule(ValidationRule):
+class UuidRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, str):
             return False
@@ -60,7 +164,7 @@ class UuidRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute must be a valid UUID."
 
-class UlidRule(ValidationRule):
+class UlidRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, str):
             return False
@@ -69,7 +173,7 @@ class UlidRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute must be a valid ULID."
 
-class IpRule(ValidationRule):
+class IpRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, str):
             return False
@@ -82,20 +186,7 @@ class IpRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute must be a valid IP address."
 
-class TimezoneRule(ValidationRule):
-    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."
-
-class HexRule(ValidationRule):
+class HexRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, str):
             return False

validator/rules/numeric.py

@@ -0,0 +1,188 @@
+from .base import Rule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+import decimal
+
+class NumericRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if isinstance(value, (int, float)):
+            return True
+        if not isinstance(value, str):
+            return False
+        return value.replace('.', '', 1).isdigit()
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be a number."
+    
+class IntegerRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if isinstance(value, int):
+            return True
+        if not isinstance(value, str):
+            return False
+        return value.isdigit()
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be an integer."
+
+class DigitsRule(Rule):
+    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:
+            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."
+
+class DigitsBetweenRule(Rule):
+    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])
+        except ValueError:
+            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."
+    
+class DecimalRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        try:
+            decimal.Decimal(str(value))
+            return True
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return "The :attribute must be a decimal number."
+
+class GreaterThanRule(Rule):
+    _name = 'gt'
+    
+    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))
+            return numeric_value > threshold
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be greater than {params[0]}."
+
+class GreaterThanOrEqualRule(Rule):
+    _name = 'gte'
+    
+    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))
+            return numeric_value >= threshold
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be greater than or equal to {params[0]}."
+
+class LessThanRule(Rule):
+    _name = 'lt'
+    
+    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))
+            return numeric_value < threshold
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be less than {params[0]}."
+
+class LessThanOrEqualRule(Rule):
+    _name = 'lte'
+    
+    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))
+            return numeric_value <= threshold
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be less than or equal to {params[0]}."
+
+class MaxDigitsRule(Rule):
+    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))
+            str_value = str(numeric_value).replace("-", "")
+            if '.' in str_value:
+                str_value = str_value.replace(".", "")
+            return len(str_value) <= max_digits
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must not exceed {params[0]} digits."
+
+class MinDigitsRule(Rule):
+    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))
+            str_value = str(numeric_value).replace("-", "")
+            if '.' in str_value:
+                str_value = str_value.replace(".", "")
+            return len(str_value) >= min_digits
+        except (decimal.InvalidOperation, TypeError, ValueError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must have at least {params[0]} digits."
+
+class MultipleOfRule(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 False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be a multiple of {params[0]}."