safeshield 1.0.0__py3-none-any.whl

validator/rules/conditional.py

@@ -0,0 +1,332 @@
+from .base import ValidationRule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+from enum import Enum
+import re
+import inspect
+from collections.abc import Iterable
+
+# =============================================
+# CONDITIONAL VALIDATION RULES
+# =============================================
+
+class RequiredIfRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 2 or len(params) % 2 != 0:
+            return True
+            
+        conditions = list(zip(params[::2], params[1::2]))
+        
+        condition_met = False
+        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 not condition_met:
+            return True
+            
+        return not self.is_empty(value)
+    
+    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
+            ]
+        
+        if not valid_conditions:
+            return f"Invalid required_if rule configuration for {field}"
+            
+        return f"The :name field is required when any of these are true: {', '.join(valid_conditions)}"
+    
+class RequiredAllIfRule(ValidationRule):
+    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 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
+    
+    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):
+    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 self.is_empty(value)
+    
+    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):
+    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 self.is_empty(value)
+    
+    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):
+    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))}"
+    
+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):
+    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]
+        
+        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]
+        
+        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 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):
+    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 :name and {params[0]} must match."
+
+class DifferentRule(ValidationRule):
+    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 :name and {params[0]} must be different."
+
+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
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be accepted."
+
+class DeclinedRule(ValidationRule):
+    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
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be declined."
+
+
+class BailRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        self.validator._stop_on_first_failure = True
+        return True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return ""

validator/rules/date.py

@@ -0,0 +1,154 @@
+from .base import ValidationRule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+from datetime import datetime
+from dateutil.parser import parse
+
+class DateRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str):
+            return False
+            
+        try:
+            parse(value)
+            return True
+        except ValueError:
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name is not a valid date."
+
+class DateEqualsRule(ValidationRule):
+    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[0] = self.get_field_value(params[0], params[0])
+            
+            date2 = parse(params[0])
+            return date1 == date2
+        except ValueError as e:
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be equal to {params[0]}."
+    
+class AfterRule(ValidationRule):
+    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):
+                date_value = value
+            else:
+                return False
+                
+            # Parse comparison date
+            params[0] = self.get_field_value(params[0], params[0])
+            compare_date = parse(params[0])
+            
+            return date_value > compare_date
+            
+        except (ValueError, TypeError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be after {params[0]}"
+    
+class AfterOrEqualRule(ValidationRule):
+    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)
+            elif isinstance(value, datetime):
+                date_value = value
+            else:
+                return False
+            
+            params[0] = self.get_field_value(params[0], params[0])
+            compare_date = parse(params[0])
+            
+            return date_value >= compare_date
+            
+        except (ValueError, TypeError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be after or equal to {params[0]}"
+    
+class BeforeRule(ValidationRule):
+    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:
+            if isinstance(value, str):
+                date_value = parse(value)
+            elif isinstance(value, datetime):
+                date_value = value
+            else:
+                return False
+            
+            params[0] = self.get_field_value(params[0], params[0])    
+            compare_date = parse(params[0])
+            
+            return date_value < compare_date
+            
+        except (ValueError, TypeError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be before {params[0]}"
+    
+class BeforeOrEqualRule(ValidationRule):
+    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:
+            if isinstance(value, str):
+                date_value = parse(value)
+            elif isinstance(value, datetime):
+                date_value = value
+            else:
+                return False
+            
+            params[0] = self.get_field_value(params[0], params[0])
+            compare_date = parse(params[0])
+            
+            return date_value <= compare_date
+            
+        except (ValueError, TypeError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be before or equal to {params[0]}"
+    
+class DateFormatRule(ValidationRule):
+    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
+        except ValueError:
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must match the format {params[0]}"

validator/rules/files.py

@@ -0,0 +1,167 @@
+from .base import ValidationRule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+
+class FileRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        # 1. Cek file object framework (Flask/Werkzeug/FastAPI)
+        if (hasattr(value, 'filename') and 
+            hasattr(value, 'stream') and 
+            hasattr(value, 'content_type')):
+            return True
+            
+        # 2. Cek file-like object umum
+        if hasattr(value, 'read') and callable(value.read):
+            return True
+            
+        # 3. Cek path file yang valid (string)
+        if isinstance(value, str):
+            return (
+                '.' in value and                  # Harus punya extension
+                not value.startswith('data:') and # Bukan data URI
+                not value.strip().startswith('<') # Bukan XML/HTML
+            )
+            
+        # 4. Cek binary data langsung
+        if isinstance(value, (bytes, bytearray)):
+            return len(value) > 0  # Pastikan tidak kosong
+            
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The {field} must be a valid file"
+
+class DimensionsRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        try:
+            from PIL import Image
+            import io
+
+            # 1. Parse dimension rules
+            min_width = min_height = 0
+            max_width = max_height = float('inf')
+            
+            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))
+                
+                # Case 3: File path (string)
+                elif isinstance(value, str) and value.lower().endswith(('.jpg', '.jpeg', '.png', '.gif')):
+                    img = Image.open(value)
+                
+                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)
+
+            except (IOError, OSError, AttributeError) as e:
+                print(f"Image loading failed: {str(e)}")
+                return False
+
+        except Exception as e:
+            print(f"Unexpected error in dimension validation: {str(e)}")
+            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]
+        
+        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 {field} dimensions must be {' and '.join(messages)}"
+    
+class ExtensionsRule(ValidationRule):
+    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)
+        ).lower()
+        
+        if '.' not in filename:
+            return False
+            
+        ext = filename.rsplit('.', 1)[1]
+        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)}"
+    
+class ImageRule(ValidationRule):
+    VALID_EXTENSIONS = {'jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'}
+    VALID_MIME_TYPES = {
+        'image/jpeg', 'image/png', 
+        'image/gif', 'image/bmp', 'image/webp'
+    }
+
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        # Check basic file attributes
+        if not hasattr(value, 'filename') and not isinstance(value, (str, bytes)):
+            return False
+            
+        # Check extension if available
+        if hasattr(value, 'filename'):
+            ext = value.filename.rsplit('.', 1)[-1].lower()
+            if ext not in self.VALID_EXTENSIONS:
+                return False
+                
+        # Check MIME type if available
+        if hasattr(value, 'content_type'):
+            if value.content_type not in self.VALID_MIME_TYPES:
+                return False
+                
+        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)"
+    
+class MimeTypesRule(ValidationRule):
+    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
+            
+        # Check from mimetype attribute
+        if hasattr(value, 'mimetype'):
+            return value.mimetype in params
+            
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"File {field} must be one of these types: {', '.join(params)}"