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

validator/rules/string.py

@@ -1,4 +1,4 @@
-from .base import ValidationRule
+from .base import Rule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 import re
 
@@ -6,49 +6,56 @@ import re
 # STRING VALIDATION RULES
 # =============================================
 
-class AlphaRule(ValidationRule):
+class StringRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        return isinstance(value, str)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be a string."
+
+class AlphaRule(Rule):
     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 :attribute may only contain letters."
 
-class AlphaDashRule(ValidationRule):
+class AlphaDashRule(Rule):
     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 :attribute may only contain letters, numbers, dashes and underscores."
 
-class AlphaNumRule(ValidationRule):
+class AlphaNumRule(Rule):
     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 :attribute may only contain letters and numbers."
 
-class UppercaseRule(ValidationRule):
+class UppercaseRule(Rule):
     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 :attribute must be uppercase."
 
-class LowercaseRule(ValidationRule):
+class LowercaseRule(Rule):
     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 :attribute must be lowercase."
 
-class AsciiRule(ValidationRule):
+class AsciiRule(Rule):
     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 :attribute must only contain ASCII characters."
     
-class StartsWithRule(ValidationRule):
+class StartsWithRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, str):
             return False
@@ -56,8 +63,17 @@ class StartsWithRule(ValidationRule):
     
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute must start with one of the following: {', '.join(params)}."
+    
+class DoesntStartWithRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str) or not params:
+            return False
+        return all(not value.startswith(prefix) for prefix in params)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must not start with any of: {', '.join(params)}"
 
-class EndsWithRule(ValidationRule):
+class EndsWithRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not isinstance(value, str):
             return False
@@ -65,3 +81,46 @@ class EndsWithRule(ValidationRule):
     
     def message(self, field: str, params: List[str]) -> str:
         return f"The :attribute must end with one of the following: {', '.join(params)}."
+    
+class DoesntEndWithRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, str) or not params:
+            return False
+        return all(not value.endswith(suffix) for suffix in params)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must not end with any of: {', '.join(params)}"
+    
+class ConfirmedRule(Rule):
+    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 :attribute confirmation does not match."
+    
+class RegexRule(Rule):
+    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 :attribute format is invalid."
+
+class NotRegexRule(Rule):
+    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 :attribute format is invalid."

validator/rules/utilities.py

@@ -1,7 +1,58 @@
-from .base import ValidationRule
+from .base import Rule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
-from .basic import AcceptedRule, DeclinedRule, ExcludeRule, RequiredRule, PresentRule, MissingRule, ProhibitedRule
+from .basic import *
+from .boolean import AcceptedRule, DeclinedRule
 
+class RequiredIfRule(RequiredRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and isinstance(params[0], bool):
+            condition_met = params[0]
+        else:  
+            conditions = list(zip(params[::2], params[1::2]))
+            
+            condition_met = any(
+                str(self.get_field_value(field, '')) == str(expected_value)
+                for field, expected_value in conditions
+                if field and expected_value is not None
+            )
+                
+        if condition_met:
+            return super().validate(field, value, params)
+        
+        return True
+    
+class RequiredUnlessRule(RequiredRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 2:
+            return False
+            
+        other_field, other_value = params[0], params[1]
+        actual_value = self.get_field_value(other_field, '') 
+        
+        if actual_value == other_value:
+            return True
+            
+        return super().validate(field, value, params)
+    
+class RequiredAllIfRule(RequiredRule):
+    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 super().validate(field, value, params)
+    
 class RequiredWithRule(RequiredRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
@@ -38,101 +89,225 @@ class RequiredWithoutAllRule(RequiredRule):
             return super().validate(field, value, params)
         return True
     
-class PresentWithRule(PresentRule):
+class RequiredIfAcceptedRule(RequiredRule, AcceptedRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
-        if any(self.get_field_value(param, None) is not None for param in params):
+        
+        if AcceptedRule.validate(self, field, params[0], params):
             return super().validate(field, value, params)
         
         return True
     
-class PresentWithAllRule(PresentRule):
+class RequiredIfDeclinedRule(RequiredRule, DeclinedRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
         
-        if all(self.get_field_value(param, None) is not None for param in params):
+        if DeclinedRule.validate(self, field, params[0], params):
             return super().validate(field, value, params)
         
-class MissingWithRule(MissingRule):
+        return True
+    
+class RequiredArrayKeysRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
+        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 :attribute must contain all required keys: {', '.join(params)}"
+    
+class ProhibitedIfRule(ProhibitedRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and isinstance(params[0], bool):
+            condition_met = params[0]
+        else:    
+            other_field, other_value = params[0], params[1]
+            actual_value = self.get_field_value(other_field, '')
         
-        if any(self.get_field_value(param, None) is not None for param in params):
+            condition_met = actual_value == other_value
+        
+        if condition_met:
             return super().validate(field, value, params)
+        return True            
+    
+class ProhibitedUnlessRule(ProhibitedRule):
+    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, '') 
         
-        return True
+        if actual_value == other_value:
+            return True
+            
+        return super().validate(field, value, params)
     
-class MissingWithAllRule(MissingRule):
+class ProhibitedIfAcceptedRule(ProhibitedRule, AcceptedRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
         
-        if all(self.get_field_value(param, None) is not None for param in params):
+        if AcceptedRule.validate(self, field, params[0], params):
             return super().validate(field, value, params)
-        
         return True
 
-class ExcludeWithRule(ExcludeRule):
+class ProhibitedIfDeclinedRule(ProhibitedRule, DeclinedRule):
     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):
+        if not params:
+            return False
+        
+        if DeclinedRule.validate(self, field, params[0], params):
             return super().validate(field, value, params)
-            
+        
         return True
     
-class ExcludeWithoutRule(ExcludeRule):
+class PresentIfRule(PresentRule):
     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):
-            return super().validate(field, value, params)
+        condition_met = False
+        
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and isinstance(params[0], bool):
+            condition_met = params[0]
+        else:
+            conditions = list(zip(params[::2], params[1::2]))
+            for other_field, expected_value in conditions:
+                if self.get_field_value(other_field, None) == expected_value:
+                    condition_met = True
+                    break
             
+        if condition_met:
+            return super().validate(field, value, params)
+        
         return True
     
-class ProhibitedIfAcceptedRule(ProhibitedRule, AcceptedRule):
+class PresentUnlessRule(PresentRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
+        if len(params) < 2:
             return False
+        other_field, other_value = params[0], params[1]
         
-        if AcceptedRule.validate(self, field, params[0], params):
+        if self.get_field_value(other_field, None) != other_value:
             return super().validate(field, value, params)
+        
         return True
-
-class ProhibitedIfDeclinedRule(ProhibitedRule, DeclinedRule):
+    
+class PresentWithRule(PresentRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
-        
-        if DeclinedRule.validate(self, field, params[0], params):
+        if any(self.get_field_value(param, None) is not None for param in params):
             return super().validate(field, value, params)
         
         return True
     
-class RequiredIfAcceptedRule(RequiredRule, AcceptedRule):
+class PresentWithAllRule(PresentRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
         
-        if AcceptedRule.validate(self, field, params[0], params):
+        if all(self.get_field_value(param, None) is not None for param in params):
+            return super().validate(field, value, params)
+
+class MissingIfRule(MissingRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        condition_met = False
+        
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and isinstance(params[0], bool):
+            condition_met = params[0]
+        else:
+            conditions = list(zip(params[::2], params[1::2]))
+            for other_field, expected_value in conditions:
+                if self.get_field_value(other_field, None) == expected_value:
+                    condition_met = True
+                    break
+            
+        if condition_met:
             return super().validate(field, value, params)
         
         return True
     
-class RequiredIfDeclinedRule(RequiredRule, DeclinedRule):
+class MissingUnlessRule(MissingRule):
+    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]
+        if self.get_field_value(other_field, None) != other_value:
+            return super().validate(field, value, params)
+
+        return True
+            
+class MissingWithRule(MissingRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
         
-        if DeclinedRule.validate(self, field, params[0], params):
+        if any(self.get_field_value(param, None) is not None for param in params):
             return super().validate(field, value, params)
         
         return True
     
-class RequiredArrayKeysRule(ValidationRule):
+class MissingWithAllRule(MissingRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not isinstance(value, dict) or not params:
+        if not params:
             return False
-        return all(key in value for key in params)
+        
+        if all(self.get_field_value(param, None) is not None for param in params):
+            return super().validate(field, value, params)
+        
+        return True
     
+class ExcludeIfRule(ExcludeRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and isinstance(params[0], bool):
+            condition_met = params[0]
+        else:
+            conditions = list(zip(params[::2], params[1::2]))
+            condition_met = all(
+                str(self.get_field_value(f)) == str(v) 
+                for f, v in conditions
+            )
+        
+        if condition_met:
+            return super().validate(field, value, params)
+        return True
+
+class ExcludeUnlessRule(ExcludeRule):
+    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:
+            return super().validate(field, value, params)
+            
+        return True
+            
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must contain all required keys: {', '.join(params)}"
+        return f"The :attribute field is excluded unless {params[0]} is {params[1]}."
+
+class ExcludeWithRule(ExcludeRule):
+    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):
+            return super().validate(field, value, params)
+            
+        return True
+    
+class ExcludeWithoutRule(ExcludeRule):
+    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):
+            return super().validate(field, value, params)
+            
+        return True

validator/services/rule_conflict.py

@@ -58,11 +58,11 @@ class RuleConflictChecker:
     }
 
     @classmethod
-    def check_conflicts(cls, rules: List['ValidationRule']) -> None:
+    def check_conflicts(cls, rules: List['Rule']) -> None:
         """Main method untuk mengecek semua jenis konflik.
         
         Args:
-            rules: List of ValidationRule objects to check
+            rules: List of Rule objects to check
             
         Raises:
             ValueError: Untuk konflik kritis

validator/services/rule_error_handler.py

@@ -114,7 +114,7 @@ class RuleErrorHandler:
             return []
         
         pairs = []
-        params = self._current_params.copy()
+        params = list(self._current_params).copy()
         
         # Process parameters in pairs (field, value)
         while len(params) >= 2:
@@ -129,9 +129,11 @@ class RuleErrorHandler:
         for placeholder, replacement in replacements.items():
             if replacement is not None:
                 # Use regex to avoid partial replacements
+                safe_replacement = re.escape(str(replacement))
+                safe_replacement = safe_replacement.replace('\\', r'')
                 message = re.sub(
                     re.escape(placeholder) + r'(?![a-zA-Z0-9_])', 
-                    str(replacement), 
+                    safe_replacement, 
                     message
                 )
         return message

validator/services/rule_preparer.py

@@ -1,6 +1,6 @@
 from validator.factory import RuleFactory
 from validator.services.rule_conflict import RuleConflictChecker
-from validator.rules import ValidationRule
+from validator.rules import Rule
 from typing import Dict, List, Union, Tuple
 from validator.exceptions import RuleNotFoundException
 from collections.abc import Iterable, Sequence
@@ -14,7 +14,7 @@ class RulePreparer:
     def __init__(self, rule_factory: RuleFactory):
         self.rule_factory = rule_factory
 
-    def prepare(self, raw_rules: Dict[str, Union[str, List[Union[str, ValidationRule]]]]) -> Dict[str, List[ValidationRule]]:
+    def prepare(self, raw_rules: Dict[str, Union[str, List[Union[str, Rule]]]]) -> Dict[str, List[Rule]]:
         """Convert raw rules to prepared validation rules"""
         prepared_rules = {}
         for field, rule_input in raw_rules.items():
@@ -25,18 +25,18 @@ class RulePreparer:
             prepared_rules[field] = self._deduplicate_rules(rules)
         return prepared_rules
 
-    def _convert_to_rules(self, rule_input: Union[str, List[Union[str, ValidationRule]], ValidationRule, Tuple[Union[str, ValidationRule], str], Tuple[Union[str, ValidationRule], str]]) -> List[ValidationRule]:
-        """Convert mixed rule input to list of ValidationRule objects"""
+    def _convert_to_rules(self, rule_input: Union[str, List[Union[str, Rule]], Rule, Tuple[Union[str, Rule], str], Tuple[Union[str, Rule], str]]) -> List[Rule]:
+        """Convert mixed rule input to list of Rule objects"""
         if rule_input is None:
             return []
-        if isinstance(rule_input, ValidationRule):
+        if isinstance(rule_input, Rule):
             return [rule_input]
-        if isinstance(rule_input, list):
+        if isinstance(rule_input, list | tuple):
             rules = []
             for r in rule_input:
                 if isinstance(r, str):
                     rules.extend(self._parse_rule_string(r))
-                elif isinstance(r, ValidationRule):
+                elif isinstance(r, Rule):
                     rules.append(r)
                 elif isinstance(r, (tuple, list)):
                     if len(r) == 0:
@@ -50,10 +50,10 @@ class RulePreparer:
                         if isinstance(rule_name, str):
                             rule = RuleFactory.create_rule(rule_name)
                             rule.params = params
-                        elif isinstance(rule_name, ValidationRule):
+                        elif isinstance(rule_name, Rule):
                             rule = rule_name
                             if params:
-                                warnings.warn(f"Parameters {params} are ignored for ValidationRule instance")
+                                warnings.warn(f"Parameters {params} are ignored for Rule instance")
                         else:
                             raise ValueError(f"Invalid rule name type in {r}")
                             
@@ -65,8 +65,8 @@ class RulePreparer:
             return self._parse_rule_string(rule_input)
         raise ValueError(f"Invalid rule input type: {type(rule_input)}")
 
-    def _parse_rule_string(self, rule_str: str) -> List[ValidationRule]:
-        """Parse rule string into ValidationRule objects"""
+    def _parse_rule_string(self, rule_str: str) -> List[Rule]:
+        """Parse rule string into Rule objects"""
         rules = []
         for rule_part in rule_str.split('|'):
             rule_part = rule_part.strip()
@@ -93,22 +93,9 @@ class RulePreparer:
         return rule_name, [p.strip() for p in param_str.split(',') if p.strip()]
     
     def _parse_params(self, params: Union[Tuple, List, str, Enum]):
-        all_params = []
-        # seen = set()
-        # for param in params:
-        #     if isinstance(param, Iterable) and not isinstance(param, str | bytes) and not inspect.isclass(param):
-        #         for item in param:
-        #             if item not in seen and item not in (None, '', [], {}) and (isinstance(item, (Number, Sequence)) or inspect.isclass(item)):
-        #                 seen.add(item)
-        #                 all_params.append(item)
-        #     else:
-        #         if param not in seen and param not in (None, '', [], {}) and (isinstance(param, (Number, Sequence)) or inspect.isclass(param)):
-        #             seen.add(param)
-        #             all_params.append(param)
-                    
         return set(tuple(x) if isinstance(x, list) else x for x in params)
 
-    def _deduplicate_rules(self, rules: List[ValidationRule]) -> List[ValidationRule]:
+    def _deduplicate_rules(self, rules: List[Rule]) -> List[Rule]:
         """Remove duplicate rules based on name and parameters"""
         seen = set()
         unique = []

safeshield-1.3.2.dist-info/RECORD

@@ -1,31 +0,0 @@
-validator/__init__.py,sha256=udxDzUicPfxBOAQvzsnl3pHur9VUppKbWMgg35hpiww,244
-validator/exceptions.py,sha256=y2v7CaXmeGFHWcnigtLl4U-sFta_jMiXkGKXWIIVglY,366
-validator/factory.py,sha256=bImQNLhEJg5VTxtHiMYVb2EbHWvimTDqHq-UcA8uolw,812
-validator/core/__init__.py,sha256=ZcqlXJSk03i_CVzmIN-nVe1UOyvwwO5jhbEj7f62Y_o,59
-validator/core/validator.py,sha256=Yaw7__Hf-PuKcXaJ6yaARPEyeofEaoqt5-N3tJZ_jtg,12741
-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=nDE3qoI82qJTCbILLUWkXuwsMOmsDtB1m-3IGIvRfpY,919
-validator/rules/array.py,sha256=3hgD_b2K61fG-xT1UdssHMOdIQKWw5vkdpovNn-kc8E,2835
-validator/rules/base.py,sha256=hrGESfkdvqZrQ1yIK_ftVVOMUuyvNFoz-_qaqUucSy8,3474
-validator/rules/basic.py,sha256=rL9THt3OE5QgtuxGCM_dklNpPKOdmuDP30EiSmvkgP8,9656
-validator/rules/comparison.py,sha256=Tlg3AfjTd-W1RonmhT0PLP_mf4CSyhpl7EsmCEYzEAA,9446
-validator/rules/conditional.py,sha256=M4x9g2LQTXNaNfb7dHRMs6vUseDu3WC1RB41QGiNABQ,5965
-validator/rules/date.py,sha256=sPrq8OgHMyUxRAZch4yt7K3I0lInIIy0dUgRtAkcsMk,5313
-validator/rules/files.py,sha256=eCrarOtaRWv1UBQuv5Y6-CcyHuncyLau8V8Ocpw0NVQ,6565
-validator/rules/format.py,sha256=hyho3Cxcgjz4mqCkO_uvjrJPU1JEOK2IZL7F6Dh9oPg,3784
-validator/rules/string.py,sha256=5NToIDOqBhmUYCg1y2y2zdQ4MMLyJzL0FCTM5XhzAgc,2951
-validator/rules/type.py,sha256=B8YH1T1RBlRNNOmb-5uZKdwBc8Uk1Zj4h4xIzAtJC2M,1883
-validator/rules/utilities.py,sha256=xysxDWoP1hJQyBZhNvdzTyMsFOWsEIxFBvYPljW1coA,5340
-validator/services/__init__.py,sha256=zzKTmqL7v4niFGWHJBfWLqgJ0iTaW_69OzYZN8uInzQ,210
-validator/services/rule_conflict.py,sha256=s1RJNUY5d0WtSMHkrKulBCgJ2BZL2GE0Eu5pdAoiIbM,4943
-validator/services/rule_error_handler.py,sha256=MNgSxnakmc3f_nvGuapRmJ9woKt_-E8Wun39OCTrGB0,10273
-validator/services/rule_preparer.py,sha256=jRcMNjqq2xyZjO64Pim8jWmja5DmTzf0V_uuHG0lJTg,5621
-validator/utils/__init__.py,sha256=Yzo-xv285Be-a233M4duDdYtscuHiuBbPSX_C8yViJI,20
-validator/utils/string.py,sha256=0YACzeEaWNEOR9_7O9A8D1ItIbtWfOJ8IfrzcB8VMYA,515
-safeshield-1.3.2.dist-info/LICENSE,sha256=qugtRyKckyaks6hd2xyxOFSOYM6au1N80pMXuMTPvC4,1090
-safeshield-1.3.2.dist-info/METADATA,sha256=V17d3w6UPE698CGSm83-5C3NOm-lZrCqLJYAy8ozrHM,1984
-safeshield-1.3.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-safeshield-1.3.2.dist-info/top_level.txt,sha256=iUtV3dlHOIiMfLuY4pruY00lFni8JzOkQ3Nh1II19OE,10
-safeshield-1.3.2.dist-info/RECORD,,