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

{safeshield-1.5.1.dist-info → safeshield-1.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: safeshield
-Version: 1.5.1
+Version: 1.5.3
 Summary: Library for Help Validation Control
 Home-page: https://github.com/WunsunTarniho/py-guard
 Author: Wunsun Tarniho

safeshield-1.5.3.dist-info/RECORD

@@ -0,0 +1,31 @@
+validator/__init__.py,sha256=udxDzUicPfxBOAQvzsnl3pHur9VUppKbWMgg35hpiww,244
+validator/exceptions.py,sha256=y2v7CaXmeGFHWcnigtLl4U-sFta_jMiXkGKXWIIVglY,366
+validator/factory.py,sha256=SJ2iJmTnFS-4ccH-gzZl_7CAW7Z6YJkZbMImu-po80w,1163
+validator/core/__init__.py,sha256=ZcqlXJSk03i_CVzmIN-nVe1UOyvwwO5jhbEj7f62Y_o,59
+validator/core/validator.py,sha256=cflLhGo_rS6Zh61X7lZfr0q-xR0bBHfylGudZ1uTn7o,12765
+validator/database/__init__.py,sha256=O-cB6-MhNapJ3iwe5jvifbMfr1dPjXLtEdfNTKIu0hc,171
+validator/database/detector.py,sha256=Vac7oVL26GjU6expGo01-6mgUtXqldr-jirzpYokZBM,9597
+validator/database/manager.py,sha256=XJM_I0WaWfZWV710duAc32p1gtiP2or-MAj75WPw1oM,6478
+validator/rules/__init__.py,sha256=z3Vk3R5CRgjeqyDWZxdofD2tBMTgdyYVuFmo1mKOTj4,830
+validator/rules/array.py,sha256=7xwdXnthWZNDbD4lONgqtOf44OOQq1J6XexYm6BXea4,3512
+validator/rules/base.py,sha256=yhxQdGiiM-wY7VtRH-KRU-_wmw7RVJnmJcmayO1EqBk,5870
+validator/rules/basic.py,sha256=8k-REzsSyknhNuw0vPKMxtovvJBVlyZDihXXVznRQpM,6420
+validator/rules/boolean.py,sha256=UuSO9BdBMR5l6sB3dgZqoqOVjqu47yjFrmJ7xylTVKs,5452
+validator/rules/comparison.py,sha256=BnufmgCkSqzUjSFWvlsKN8auOCKTBs7Pxy5i9rwSQs8,15564
+validator/rules/date.py,sha256=k27U3e08OPZoXyEX0Yj86ZfjCUuhLy4eBmqYbyc4Jn4,7292
+validator/rules/files.py,sha256=3Q0KoadDKqNIiVlBR7b5b-XBs4gOg3ZFu7wU7SrdqWQ,12280
+validator/rules/format.py,sha256=u_BhPQwW30JYHwZIjHD0ZX449csgTPPCJOeoXaQr4M4,7361
+validator/rules/numeric.py,sha256=UgawwV_ZKiJ3Dano32UrSBC6Qe69zbiL69OyMDo91yY,8699
+validator/rules/string.py,sha256=3wgrqAO4V97ZPMc97mwDV6vsNvs6oyJs-ciqQX-FLBs,6268
+validator/rules/utilities.py,sha256=BaErsE0TPt1u342aOuSBkjh0CMD2Sq7ZwiBqM8j0GLo,16910
+validator/services/__init__.py,sha256=zzKTmqL7v4niFGWHJBfWLqgJ0iTaW_69OzYZN8uInzQ,210
+validator/services/rule_conflict.py,sha256=T3IhWLmZsRUccJ4oFO-OKRjrc5Xt7r71kktxjjj2IA8,9505
+validator/services/rule_error_handler.py,sha256=l4jA6WtTRBNGytVA_nSwJpbix_viNWhqlwKcxIKXzcY,2325
+validator/services/rule_preparer.py,sha256=7HSMuSGGgaYWv8dt_m7pL5MQkJcTwFBH9gfmCZwzt8U,5284
+validator/utils/__init__.py,sha256=Yzo-xv285Be-a233M4duDdYtscuHiuBbPSX_C8yViJI,20
+validator/utils/string.py,sha256=0YACzeEaWNEOR9_7O9A8D1ItIbtWfOJ8IfrzcB8VMYA,515
+safeshield-1.5.3.dist-info/LICENSE,sha256=qugtRyKckyaks6hd2xyxOFSOYM6au1N80pMXuMTPvC4,1090
+safeshield-1.5.3.dist-info/METADATA,sha256=afpA0oU6UvthlLNjUBW9q3ojPU9teOQdNVSdhrfHOjw,2313
+safeshield-1.5.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+safeshield-1.5.3.dist-info/top_level.txt,sha256=iUtV3dlHOIiMfLuY4pruY00lFni8JzOkQ3Nh1II19OE,10
+safeshield-1.5.3.dist-info/RECORD,,

validator/core/validator.py

@@ -12,7 +12,7 @@ from collections.abc import Mapping
 class Validator:
     """Main validation class with proper abstractions"""
     PRIORITY_RULES = {
-        'bail', 'sometimes', 'exclude', 'exclude_unless', 'exclude_if', 'exclude_with', 'exclude_without', 'required', 'required_if', 'required_unless',
+        'bail', 'sometimes', 'dynamic', 'exclude', 'exclude_unless', 'exclude_if', 'exclude_with', 'exclude_without', 'required', 'required_if', 'required_unless',
         'required_with', 'required_without'
     }
 
@@ -60,6 +60,7 @@ class Validator:
     ):
         self.data = data or {}
         self._raw_rules = rules or {}
+        self.prepared_rules = None
         self._stop_on_first_failure = False
         self._field_to_exclude = []
         
@@ -67,6 +68,7 @@ class Validator:
         # Initialize dependencies
         self.rule_preparer = RulePreparer(RuleFactory())
         self.error_handler = RuleErrorHandler(messages, custom_attributes)
+        self.custom_attributes = custom_attributes or {}
         
         # Database configuration
         self.db_config = db_config or DatabaseAutoDetector.detect()
@@ -79,21 +81,22 @@ class Validator:
 
     def validate(self) -> bool:
         """Validate the data against the rules"""
-        prepared_rules = self.rule_preparer.prepare(self._raw_rules)
+        self.prepared_rules = self.rule_preparer.prepare(self._raw_rules)
         self.error_handler.errors.clear()
-
-        validated = self._validate_rules(prepared_rules, priority_only=True)
+        
+        validated = self._validate_rules(self.prepared_rules, priority_only=True)
         
         # First pass: priority rules
         if self.error_handler.has_errors and self._stop_on_first_failure:
             return False
-
+        
         # Second pass: remaining rules
-        self._validate_rules(prepared_rules, priority_only=False)
+        self._validate_rules(self.prepared_rules, priority_only=False)
         
         if self.error_handler.has_errors:
             return False
-        return True
+        
+        return self.data
 
     def _validate_rules(self, prepared_rules: Dict[str, List[Rule]], priority_only: bool):
         validated = []
@@ -219,22 +222,18 @@ class Validator:
         return _check(self.data, parts)
     
     def _apply_rule(self, field: str, value: Any, rule: Rule) -> bool:
-        try:
-            rule.set_validator(self)
+        rule.set_validator(self)
             
-            display_field = getattr(self, '_current_actual_path', field)
+        display_field = getattr(self, '_current_actual_path', field)
+        rule._require_parameter_count(getattr(rule, '_count_parameter', 0), getattr(rule, 'params', []), rule)
             
-            if not rule.validate(field, value, getattr(rule, 'params', [])):
-                msg = rule.message(display_field, getattr(rule, 'params', []))
-                self.error_handler.add_error(display_field, rule.rule_name, getattr(rule, 'params', []), msg, value)
+        if not rule.validate(field, value, getattr(rule, 'params', [])):
+            msg = rule.message(display_field, getattr(rule, 'params', []))
+            self.error_handler.add_error(display_field, rule, getattr(rule, 'params', []), msg, value)
             
-                return False
-            else:
-                return True
-        except Exception as e:
-            display_field = getattr(self, '_current_actual_path', field)
-            self.error_handler.add_error(display_field, rule.rule_name, getattr(rule, 'params', []), str(e), value)
             return False
+        else:
+            return True
 
     def _get_nested_value(self, path: str) -> Any:
         parts = path.split('.')
@@ -293,6 +292,9 @@ class Validator:
     def errors(self) -> Dict[str, List[str]]:
         """Get current validation errors"""
         return self.error_handler.errors
+    
+    def get_errors(self):
+        return self.error_handler.errors or {}
 
     @property
     def has_errors(self) -> bool:

validator/rules/array.py

@@ -3,24 +3,30 @@ from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 
 class ArrayRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        self._missing_keys = params
-        
         if params:
             params = self._parse_option_values(self.rule_name, params)
             if not isinstance(value, dict):
                 return False
-
+            
             missing = [param for param in params if param not in value]
-            self._missing_keys = missing
             return len(missing) == 0
 
         return isinstance(value, (list, tuple, set))
 
     def message(self, field: str, params: List[str]) -> str:
         if params:
-            return f"The :attribute must contain the keys: {', '.join(self._missing_keys)}."
+            return f"The :attribute must contain the keys: :values."
         return f"The :attribute must be an array."
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._params)
+        }
+        
+        return replacements
+    
 class DistinctRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, (list, tuple, set)):
@@ -48,23 +54,51 @@ class DistinctRule(Rule):
             return f"{base_msg} (case insensitive)"
         else:
             return f"{base_msg} (strict comparison)"
+        
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':value': self._params[0] if self._params else None
+        }
+        
+        return replacements
     
 class InArrayRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
-        return str(value) in params
+        return str(value) in self.get_field_value(params[0], [])
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must be one of: {', '.join(params)}"
+        return f"The :attribute must be one of: :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self.get_field_value(self._params[0], []))
+        }
+        
+        return replacements
     
 class InArrayKeysRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or not isinstance(value, dict):
+        if not isinstance(value, dict):
             return False
             
         return any(key in value for key in params)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must contain at least one of these keys: {', '.join(params)}"
+        return f"The :attribute must contain at least one of these keys: :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':values': ', '.join(self._params)
+        }
+        
+        return replacements

validator/rules/base.py

@@ -8,20 +8,15 @@ class Rule(ABC):
     """Abstract base class for all validation rules"""
     
     _rule_classes: Dict[str, Type['Rule']] = {}
-    _rule_cache: Dict[str, 'Rule'] = {}
     
     def __init__(self, *params: str):
         self._validator: Optional['Validator'] = None
         self._params: List[str] = list(params)
         
-    def __init_subclass__(cls, name=None):
+    def __init_subclass__(cls):
         cls.rule_name = cls.pascal_to_snake(cls.__name__) if not hasattr(cls, '_name') else cls._name
         cls._register_rule_class()
         cls._generate_rule_methods()
-    
-    @classmethod
-    def _register_rule_class(cls):
-        cls._rule_classes[cls.rule_name] = cls
         
     @property
     def params(self):
@@ -33,6 +28,10 @@ class Rule(ABC):
                 params.append(rule_set)
         return tuple(params)
     
+    @classmethod
+    def _register_rule_class(cls):
+        cls._rule_classes[cls.rule_name] = cls
+    
     @classmethod
     def _generate_rule_methods(cls):
         for rule_name, rule_class in cls._rule_classes.items():
@@ -42,6 +41,14 @@ class Rule(ABC):
             
             setattr(cls.__class__, rule_name, method)
             
+    @classmethod
+    def _require_parameter_count(self, count, params, rule):
+        if getattr(rule, '_accept_closure', False) and (isinstance(params[0], bool) or callable(params[0])):
+            return
+        
+        if count > len(params):
+            raise ValueError(f"Validation rule {rule.rule_name} requires at least {count} parameter")
+            
     @params.setter
     def params(self, value: List[str]) -> None:
         self._params = value
@@ -81,6 +88,35 @@ class Rule(ABC):
         """Generate an error message if validation fails."""
         pass
     
+    def replacements(self, field, value) -> Dict[str, str]:
+        """Default replacements for all rules"""
+        return {':attribute': self._get_display_name(field), 'value': value }
+    
+    def _get_display_name(self, fields: str) -> str:
+        single_input = isinstance(fields, str)
+        if single_input:
+            fields = [fields]
+        
+        attributes = []
+        
+        for field in fields:
+            if field in self.validator.custom_attributes:
+                attributes.append(self.validator.custom_attributes[field])
+                continue
+                
+            parts = field.split('.')
+            base_name = parts[-1].replace('_', ' ').title()
+            
+            for i in range(len(parts), 0, -1):
+                wildcard = '.'.join(parts[:i]) + '.*'
+                if wildcard in self.validator.custom_attributes:
+                    attributes.append(self.validator.custom_attributes[wildcard])
+                    break
+            else:
+                attributes.append(self.validator.custom_attributes.get(parts[-1], base_name))
+        
+        return attributes[0] if single_input else attributes
+    
     @property
     @abstractmethod
     def rule_name(self) -> str:

validator/rules/basic.py

@@ -6,8 +6,10 @@ from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 # =============================================
 
 class AnyOfRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        self._last_failed_rules = []  # Reset failed rules
+        self._last_failed_rules = []
         
         for i, rule_set in enumerate(params):
             if isinstance(rule_set, str):
@@ -56,6 +58,30 @@ class AnyOfRule(Rule):
             f"The :attribute must satisfy at least one of these conditions:\n" +
             "\n".join(error_messages)
         )
+        
+class WhenRule(Rule):
+    _count_parameter = 1
+    
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        rules = [rule for rule in self.validator.prepared_rules.get(field, []) if rule.rule_name != 'when']
+        rules = [new_rule for new_rule in self.validator.rule_preparer._generate_rule(field, self._select_rules(field))]
+        self.validator.prepared_rules[field] += rules
+        
+        return True
+
+    def _select_rules(self, field: str) -> List[str]:
+        selected = None
+        for check_field, rules_map in self._params[0].items():
+            current_value = str(self.get_field_value(check_field)) if self.get_field_value(check_field) is not None else ''
+            for expected_value, rules in rules_map.items():
+                if current_value == expected_value or expected_value == '*':
+                    selected = rules
+                    break
+                
+        return selected
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return ""
 
 class BailRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -108,13 +134,29 @@ class MissingRule(Rule):
         return f"The :attribute field must be missing."
     
 class ProhibitsRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or value is None:
+        if value is None or value == '':
             return True
-        return all(self.get_field_value(param, param) in (None, 'None') for param in params)
+            
+        for param in params:
+            other_value = self.get_field_value(param, None)
+            if other_value in self.validator.data:
+                return False
+        return True
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"When :attribute is present, {', '.join(params)} must be absent."
+        return f"When :attribute is present, :others must be empty or absent."
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':others': ', '.join(self._get_display_name(self._params))
+        }
+        
+        return replacements
 
 class SometimesRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:

validator/rules/boolean.py

@@ -6,7 +6,7 @@ class BooleanRule(Rule):
         if isinstance(value, bool):
             return True
         if isinstance(value, str):
-            return value.lower() in ['true', 'false', '1', '0', 'yes', 'no', 'on', 'off']
+            return value.lower() in ['true', 'false', '1', '0', 'yes', 'no', 'on', 'off', 'False', 'True']
         if isinstance(value, int):
             return value in [0, 1]
         return False
@@ -45,6 +45,8 @@ class DeclinedRule(Rule):
         return f"The :attribute must be declined."
     
 class AcceptedIfRule(AcceptedRule):
+    _count_parameter = 2
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         condition_met = False
 
@@ -53,54 +55,52 @@ class AcceptedIfRule(AcceptedRule):
         elif len(params) == 1 and isinstance(params[0], bool):
             condition_met = params[0]
         else:  
-            conditions = list(zip(params[::2], params[1::2]))
+            expected_value = self.get_field_value(params[0], None)
+            condition = params[1]
             
-            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 expected_value == condition:
+                condition_met = True
             
         if condition_met:
             return super().validate(field, value, params)
         
         return True
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':value': self._params[1],
+        }
+        
+        return replacements
+    
 class AcceptedUnlessRule(AcceptedRule):
+    _count_parameter = 2
+    
     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, '') 
+        actual_value = self.get_field_value(other_field, None) 
         
         if actual_value == other_value:
             return True
             
         return super().validate(field, value, params)
     
-class AcceptedAllIfRule(AcceptedRule):
-    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])]
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':value': self._params[1],
+        }
         
-        all_conditions_met = all(
-            self.get_field_value(f) == v 
-            for f, v in conditions
-        )
-        
-        if not all_conditions_met:
-            return True
-            
-        return super().validate(field, value, params)
+        return replacements
     
 class DeclinedIfRule(DeclinedRule):
+    _count_parameter = 2
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         condition_met = False
                 
@@ -109,24 +109,30 @@ class DeclinedIfRule(DeclinedRule):
         elif len(params) == 1 and isinstance(params[0], bool):
             condition_met = params[0]
         else:  
-            conditions = list(zip(params[::2], params[1::2]))
+            expected_value = self.get_field_value(params[0], None)
+            condition = params[1]
+            
+            if expected_value == condition:
+                condition_met = True
             
-            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 condition_met:
                 return super().validate(field, value, params)
-            
+        
         return True
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':value': self._params[1],
+        }
+        
+        return replacements
+    
 class DeclinedUnlessRule(DeclinedRule):
+    _count_parameter = 2
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if len(params) < 2:
             return False
@@ -139,19 +145,12 @@ class DeclinedUnlessRule(DeclinedRule):
             
         return super().validate(field, value, params)
     
-class DeclinedAllIfRule(DeclinedRule):
-    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
-        )
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':value': self._params[1],
+        }
         
-        if not all_conditions_met:
-            return True
-            
-        return super().validate(field, value, params)
+        return replacements