safeshield 1.0.0__py3-none-any.whl

validator/rules/format.py

@@ -0,0 +1,105 @@
+from .base import ValidationRule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+import re
+import zoneinfo
+import ipaddress
+import json
+import uuid
+
+# =============================================
+# FORMAT VALIDATION RULES
+# =============================================
+
+class EmailRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        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))
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be a valid email address."
+
+class UrlRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str):
+            return False
+        return bool(re.match(
+            r'^(https?:\/\/)?'  # protocol
+            r'([\da-z\.-]+)\.'  # domain
+            r'([a-z\.]{2,6})'   # top level domain
+            r'([\/\w \.-]*)*\/?$',  # path/query
+            value
+        ))
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be a valid URL."
+
+class JsonRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str):
+            return False
+        try:
+            json.loads(value)
+            return True
+        except json.JSONDecodeError:
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be a valid JSON string."
+
+class UuidRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str):
+            return False
+        try:
+            uuid.UUID(value)
+            return True
+        except ValueError:
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be a valid UUID."
+
+class UlidRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str):
+            return False
+        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."
+
+class IpRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str):
+            return False
+        try:
+            ipaddress.ip_address(value)
+            return True
+        except ValueError:
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name 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 :name must be a valid timezone."
+
+class HexRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str):
+            return False
+        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."

validator/rules/string.py

@@ -0,0 +1,74 @@
+from .base import ValidationRule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+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."
+
+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."
+
+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."
+
+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."
+
+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."
+
+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."
+    
+class StartsWithRule(ValidationRule):
+    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 :name must start with one of the following: {', '.join(params)}."
+
+class EndsWithRule(ValidationRule):
+    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 :name must end with one of the following: {', '.join(params)}."

validator/rules/type.py

@@ -0,0 +1,42 @@
+from .base import ValidationRule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+from datetime import datetime
+
+# =============================================
+# TYPE DATA VALIDATION RULES
+# =============================================
+
+class NumericRule(ValidationRule):
+    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 :name must be a number."
+
+class IntegerRule(ValidationRule):
+    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 :name must be an integer."
+
+class BooleanRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if isinstance(value, bool):
+            return True
+        if isinstance(value, str):
+            return value.lower() in ['true', 'false', '1', '0', 'yes', 'no', 'on', 'off']
+        if isinstance(value, int):
+            return value in [0, 1]
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must be true or false."

validator/rules/utilities.py

@@ -0,0 +1,213 @@
+from .base import ValidationRule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+
+class AnyOfRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+        return any(self.get_field_value(param, param) == value for param in params)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be one of: {', '.join(params)}"
+
+class ExcludeRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        return False  # This rule is typically used to exclude fields from validation
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field is excluded."
+
+class ExcludeIfRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        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:
+            self.validator._is_exclude = True
+            
+        return True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field is excluded when {params[0]} is {params[1]}."
+
+class ExcludeUnlessRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        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:
+            self.validator._is_exclude = True
+            
+        return True
+            
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field is excluded unless {params[0]} is {params[1]}."
+
+class ExcludeWithRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if any(not self.is_empty(self.get_field_value(param, None)) for param in params):
+            self.validator._is_exclude = True
+            
+        return True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field is excluded when any of {', '.join(params)} is present."
+
+class ExcludeWithoutRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if any(self.is_empty(self.get_field_value(param, None)) for param in params):
+            self.validator._is_exclude = True
+            
+        return True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field is excluded when any of {', '.join(params)} is missing."
+
+class MissingRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        return value is None
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must be missing."
+
+class MissingIfRule(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]
+        return value is None if self.get_field_value(other_field, None) == other_value else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must be missing when {params[0]} is {params[1]}."
+
+class MissingUnlessRule(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]
+        return value is None if self.get_field_value(other_field, None) != other_value else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must be missing unless {params[0]} is {params[1]}."
+
+class MissingWithRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+        return value is None if any(self.get_field_value(param, None) is not None for param in params) else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must be missing when any of {', '.join(params)} is present."
+
+class MissingWithAllRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+        return value is None if all(self.get_field_value(param, None) is not None for param in params) else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must be missing when all of {', '.join(params)} are present."
+
+class PresentIfRule(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]
+        return value is not None if self.get_field_value(other_field, None) == other_value else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must be present when {params[0]} is {params[1]}."
+
+class PresentUnlessRule(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]
+        return value is not None if self.get_field_value(other_field, None) != other_value else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must be present unless {params[0]} is {params[1]}."
+
+class PresentWithRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+        return value is not None if any(self.get_field_value(param, None) is not None for param in params) else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must be present when any of {', '.join(params)} is present."
+
+class PresentWithAllRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+        return value is not None if all(self.get_field_value(param, None) is not None for param in params) else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must be present when all of {', '.join(params)} are present."
+
+class ProhibitedIfAcceptedRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+        other_field = params[0]
+        return value is None if self.get_field_value(other_field, None) in ['yes', 'on', '1', 1, True, 'true', 'True'] else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field is prohibited when {params[0]} is accepted."
+
+class ProhibitedIfDeclinedRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+        other_field = params[0]
+        return value is None if self.get_field_value(other_field, None) in ['no', 'off', '0', 0, False, 'false', 'False'] else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field is prohibited when {params[0]} is declined."
+
+class ProhibitsRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params or value is None:
+            return True
+        return all(self.get_field_value(param, param) in (None, 'None') for param in params)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"When :name is present, {', '.join(params)} must be absent."
+
+class RequiredIfAcceptedRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+        other_field = params[0]
+        return value is not None if self.get_field_value(other_field, None) in ['yes', 'on', '1', 1, True, 'true', 'True'] else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field is required when {params[0]} is accepted."
+
+class RequiredIfDeclinedRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+        other_field = params[0]
+        return value is not None if self.get_field_value(other_field, other_field) in ['no', 'off', '0', 0, False, 'false', 'False'] else True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field is required when {params[0]} is declined."
+
+class RequiredArrayKeysRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, dict) or not params:
+            return False
+        return all(key in value for key in params)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must contain all required keys: {', '.join(params)}"

validator/services/__init__.py

@@ -0,0 +1,5 @@
+from .rule_preparer import RulePreparer
+from .rule_error_handler import RuleErrorHandler
+from .rule_conflict import RuleConflictChecker
+
+__all__ = {'RulePreparer', 'RuleErrorHandler', 'RuleConflictChecker'}

validator/services/rule_conflict.py

@@ -0,0 +1,133 @@
+from typing import List, Set, Dict, Tuple
+import warnings
+
+class RuleConflictChecker:
+    """Class untuk mendeteksi dan menangani konflik antar validation rules."""
+    
+    # Daftar konflik kritis yang akan memunculkan exception
+    CRITICAL_CONFLICTS = [
+        # Mutually exclusive presence
+        ('required', 'nullable'),
+        ('required', 'sometimes'),
+        ('filled', 'prohibited_if'),
+        
+        # Type conflicts
+        ('numeric', 'email'),
+        ('numeric', 'array'),
+        ('boolean', 'integer'),
+        ('boolean', 'numeric'),
+        ('array', 'string'),
+        
+        # Format conflicts
+        ('email', 'ip'),
+        ('uuid', 'ulid'),
+        ('json', 'timezone'),
+        
+        # Value requirement conflicts
+        ('accepted', 'declined'),
+        ('same', 'different')
+    ]
+    
+    # Daftar konflik fungsional yang hanya memunculkan warning
+    WARNING_CONFLICTS = [
+        # Overlapping validation
+        ('between', 'digits_between'),
+        ('min', 'size'),
+        ('max', 'size'),
+        ('confirmed', 'same'),
+        ('in', 'not_in'),
+        
+        # Redundant type checks
+        ('integer', 'numeric'),
+        ('alpha_num', 'alpha_dash'),
+        ('starts_with', 'ends_with'),
+        
+        # Similar format checks
+        ('url', 'json'),
+        ('ulid', 'uuid')
+    ]
+    
+    # Grup rules yang saling terkait
+    REQUIRED_GROUPS = {
+        'required_with', 'required_with_all',
+        'required_without', 'required_without_all'
+    }
+    
+    PROHIBITED_GROUPS = {
+        'prohibited_if', 'prohibited_unless'
+    }
+
+    @classmethod
+    def check_conflicts(cls, rules: List['ValidationRule']) -> None:
+        """Main method untuk mengecek semua jenis konflik.
+        
+        Args:
+            rules: List of ValidationRule objects to check
+            
+        Raises:
+            ValueError: Untuk konflik kritis
+            UserWarning: Untuk konflik fungsional/potensial
+        """
+        rule_names = {r.rule_name for r in rules}
+        params_map = {r.rule_name: r.params for r in rules}
+        
+        cls._check_critical_conflicts(rule_names)
+        cls._check_warning_conflicts(rule_names)
+        cls._check_parameter_conflicts(rule_names, params_map)
+        cls._check_special_cases(rule_names)
+
+    @classmethod
+    def _check_critical_conflicts(cls, rule_names: Set[str]) -> None:
+        """Cek konflik kritis yang akan memunculkan exception."""
+        for rule1, rule2 in cls.CRITICAL_CONFLICTS:
+            if rule1 in rule_names and rule2 in rule_names:
+                raise ValueError(
+                    f"Critical rule conflict: '{rule1}' cannot be used with '{rule2}'"
+                )
+
+    @classmethod
+    def _check_warning_conflicts(cls, rule_names: Set[str]) -> None:
+        """Cek konflik fungsional yang hanya memunculkan warning."""
+        for rule1, rule2 in cls.WARNING_CONFLICTS:
+            if rule1 in rule_names and rule2 in rule_names:
+                warnings.warn(f"Potential overlap: '{rule1}' and '{rule2}' may validate similar things", UserWarning, stacklevel=2)
+
+    @classmethod
+    def _check_parameter_conflicts(cls, rule_names: Set[str], params_map: Dict[str, List[str]]) -> None:
+        """Cek konflik parameter antar rules."""
+        # Range conflicts
+        if 'min' in rule_names and 'max' in rule_names:
+            min_val = float(params_map['min'][0])
+            max_val = float(params_map['max'][0])
+            if min_val > max_val:
+                raise ValueError(f"Invalid range: min ({min_val}) > max ({max_val})")
+
+        if 'between' in rule_names:
+            between_vals = params_map['between']
+            
+            if len(between_vals) != 2:
+                raise ValueError("Between rule requires exactly 2 values")
+            min_val, max_val = map(float, between_vals)
+            if min_val >= max_val:
+                raise ValueError(f"Invalid between range: {min_val} >= {max_val}")
+
+        # Size vs length checks
+        if 'size' in rule_names and ('min' in rule_names or 'max' in rule_names):
+            warnings.warn("'size' already implies exact dimension, 'min/max' may be redundant", UserWarning)
+
+    @classmethod
+    def _check_special_cases(cls, rule_names: Set[str]) -> None:
+        """Cek special cases dan grup rules."""
+        # Required_with/without group conflicts
+        if len(cls.REQUIRED_GROUPS & rule_names) > 1:
+            warnings.warn(
+                "Multiple required_* conditions may cause unexpected behavior",
+                UserWarning
+            )
+
+        # Prohibited_if/unless conflicts
+        if len(cls.PROHIBITED_GROUPS & rule_names) > 1:
+            warnings.warn(
+                "Using both prohibited_if and prohibited_unless may be confusing",
+                UserWarning
+            )

validator/services/rule_error_handler.py

@@ -0,0 +1,42 @@
+from typing import Dict, List, Any
+
+class RuleErrorHandler:
+    """Manages validation errors and message formatting"""
+    def __init__(self, messages: Dict[str, str], custom_attributes: Dict[str, str]):
+        self.messages = messages or {}
+        self.custom_attributes = custom_attributes or {}
+        self.errors: Dict[str, List[str]] = {}
+
+    def add_error(self, field: str, rule_name: str, default_message: str, value: Any):
+        """Add formatted error message"""
+        message = self._format_message(field, rule_name, default_message, value)
+        
+        # Handle nested field display names
+        self.errors.setdefault(field, []).append(message)
+
+    def _format_message(self, field: str, rule_name: str, default_message: str, value: Any) -> str:
+        """Format error message with placeholders"""
+        # Get the base field name (last part of nested path)
+        base_field = field.split('.')[-1]
+        
+        attribute = self.custom_attributes.get(field) or self.custom_attributes.get(base_field, field)
+        value_str = str(value) if value is not None else ''
+        
+        message = (
+            self.messages.get(field) or
+            self.messages.get(attribute) or
+            self.messages.get(f"{attribute}.*") or
+            self.messages.get(f"{field}.{rule_name}") or
+            default_message
+        )
+        
+        return (message
+            .replace(':name', attribute)
+            .replace(':value', value_str)
+            .replace(':param', rule_name.split(':')[1] if ':' in rule_name else '')
+        )
+
+    @property
+    def has_errors(self) -> bool:
+        """Check if any errors exist"""
+        return bool(self.errors)