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

validator/rules/utilities.py

@@ -1,208 +1,133 @@
 from .base import ValidationRule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+from .basic import AcceptedRule, DeclinedRule, ExcludeRule, RequiredRule, PresentRule, MissingRule, ProhibitedRule
 
-class AnyOfRule(ValidationRule):
+class RequiredWithRule(RequiredRule):
     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
             
+        if any(f in self.validator.data for f in params):
+            return super().validate(field, value, params)
         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):
+class RequiredWithAllRule(RequiredRule):
     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
+        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 excluded when any of {', '.join(params)} is present."
-
-class ExcludeWithoutRule(ValidationRule):
+class RequiredWithoutRule(RequiredRule):
     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
+        if not params:
+            return False
             
+        if any(f not in self.validator.data for f in params):
+            return super().validate(field, value, params)
         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):
+class RequiredWithoutAllRule(RequiredRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
+        if not params:
             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
+            
+        if all(f not in self.validator.data for f in params):
+            return super().validate(field, value, params)
+        return 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):
+class PresentWithRule(PresentRule):
     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
+        if any(self.get_field_value(param, None) is not None for param in params):
+            return super().validate(field, value, params)
+        
+        return 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):
+class PresentWithAllRule(PresentRule):
     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):
+        
+        if all(self.get_field_value(param, None) is not None for param in params):
+            return super().validate(field, value, params)
+        
+class MissingWithRule(MissingRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
+        if not params:
             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
+        
+        if any(self.get_field_value(param, None) is not None for param in params):
+            return super().validate(field, value, params)
+        
+        return 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):
+class MissingWithAllRule(MissingRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
+        if not params:
             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]}."
+        
+        if all(self.get_field_value(param, None) is not None for param in params):
+            return super().validate(field, value, params)
+        
+        return True
 
-class PresentWithRule(ValidationRule):
+class ExcludeWithRule(ExcludeRule):
     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
+        if any(not self.is_empty(self.get_field_value(param, None)) for param in params):
+            return super().validate(field, value, params)
+            
+        return 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):
+class ExcludeWithoutRule(ExcludeRule):
     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
+        if any(self.is_empty(self.get_field_value(param, None)) for param in params):
+            return super().validate(field, value, params)
+            
+        return 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):
+class ProhibitedIfAcceptedRule(ProhibitedRule, AcceptedRule):
     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."
+        
+        if AcceptedRule.validate(self, field, params[0], params):
+            return super().validate(field, value, params)
+        return True
 
-class ProhibitedIfDeclinedRule(ValidationRule):
+class ProhibitedIfDeclinedRule(ProhibitedRule, DeclinedRule):
     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
+        
+        if DeclinedRule.validate(self, field, params[0], params):
+            return super().validate(field, value, params)
+        
+        return 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):
+class RequiredIfAcceptedRule(RequiredRule, AcceptedRule):
     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
+        
+        if AcceptedRule.validate(self, field, params[0], params):
+            return super().validate(field, value, params)
+        
+        return 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):
+class RequiredIfDeclinedRule(RequiredRule, DeclinedRule):
     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
+        
+        if DeclinedRule.validate(self, field, params[0], params):
+            return super().validate(field, value, params)
+        
+        return 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:
@@ -210,4 +135,4 @@ class RequiredArrayKeysRule(ValidationRule):
         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)}"
+        return f"The :attribute must contain all required keys: {', '.join(params)}"

validator/services/rule_error_handler.py

@@ -1,41 +1,238 @@
-from typing import Dict, List, Any
+from typing import Dict, List, Any, Optional, Union
+import re
 
 class RuleErrorHandler:
-    """Manages validation errors and message formatting"""
+    """Enhanced validation error handler with complete Laravel-style placeholder support,
+    including field-value pair parameters (field1,value1,field2,value2)"""
+    
     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]] = {}
+        self._current_rule: Optional[str] = None
+        self._current_params: Optional[List[str]] = None
+        self._current_value: Optional[Any] = None
 
-    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)
+    def add_error(self, field: str, rule_name: str, rule_params: List[str], default_message: str, value: Any) -> None:
+        """Add a formatted error message with complete placeholder support"""
+        self._current_rule = rule_name
+        self._current_params = rule_params
+        self._current_value = value
         
-        # Handle nested field display names
+        message = self._format_message(field, rule_name, default_message, value)
         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
-        )
+        """Format error message with all supported placeholders"""
+        attribute = self._get_attribute_name(field)
+        value_str = self._stringify_value(value)
+        
+        # Get the most specific message available
+        message = self._get_message(field, rule_name, attribute, default_message)
+        
+        # Prepare all possible replacements
+        replacements = self._prepare_replacements(attribute, value_str)
+        
+        # Apply replacements safely
+        return self._apply_replacements(message, replacements)
+
+    def _get_attribute_name(self, field: str) -> str:
+        """Get the display name for a field with nested field support"""
+        # Check for exact match first
+        if field in self.custom_attributes:
+            return self.custom_attributes[field]
+        
+        # Handle nested fields (e.g., 'user.profile.name')
+        parts = field.split('.')
+        for i in range(len(parts), 0, -1):
+            wildcard_key = '.'.join(parts[:i]) + '.*'
+            if wildcard_key in self.custom_attributes:
+                return self.custom_attributes[wildcard_key]
         
-        return (message
-            .replace(':name', attribute)
-            .replace(':value', value_str)
-            .replace(':param', rule_name.split(':')[1] if ':' in rule_name else '')
+        # Fallback to last part or field itself
+        return self.custom_attributes.get(parts[-1], field.replace('_', ' ').title())
+
+    def _stringify_value(self, value: Any) -> str:
+        """Convert any value to a string representation"""
+        if value is None:
+            return ''
+        if isinstance(value, (list, dict, set)):
+            return ', '.join(str(v) for v in value) if value else ''
+        return str(value)
+
+    def _get_message(self, field: str, rule_name: str, attribute: str, default: str) -> str:
+        """Get the most specific error message available"""
+        return (
+            self.messages.get(f"{field}.{rule_name}") or  # Field-specific rule message
+            self.messages.get(field) or                    # Field-specific default
+            self.messages.get(rule_name) or                # Rule-specific default
+            default                                       # Fallback
         )
 
+    def _prepare_replacements(self, attribute: str, value_str: str) -> Dict[str, str]:
+        """Prepare all placeholder replacements including field-value pairs"""
+        replacements = {
+            ':attribute': attribute,
+            ':input': value_str,
+            ':value': value_str,
+            ':values': self._get_values_param(),
+            ':min': self._get_min_param(),
+            ':max': self._get_max_param(),
+            ':size': self._get_size_param(),
+            ':other': self._get_other_param_display(),
+            ':date': self._get_date_param(),
+            ':format': self._get_format_param(),
+            ':param': self._get_first_param(),
+        }
+        
+        # Add numbered placeholders for field-value pairs (e.g., :other1, :value1, :other2, :value2)
+        if self._is_field_value_rule() and self._current_params:
+            field_value_pairs = self._get_field_value_pairs()
+            if field_value_pairs:
+                first_field, first_value = field_value_pairs[0]
+                replacements[':other'] = self._get_attribute_name(first_field)
+                replacements[':value'] = first_value
+                
+                for i, (field, val) in enumerate(field_value_pairs[1:], start=2):
+                    replacements[f':other{i}'] = self._get_attribute_name(field)
+                    replacements[f':value{i}'] = val
+        
+        return replacements
+
+    def _is_field_value_rule(self) -> bool:
+        """Check if the current rule uses field-value pairs"""
+        return self._current_rule and self._current_rule.lower() in {
+            'required_if', 'required_unless', 
+            'exclude_if', 'exclude_unless',
+            'missing_if', 'missing_unless',
+            'present_if', 'present_unless'
+        }
+
+    def _get_field_value_pairs(self) -> List[tuple]:
+        """Extract field-value pairs from parameters"""
+        if not self._current_params:
+            return []
+        
+        pairs = []
+        params = self._current_params.copy()
+        
+        # Process parameters in pairs (field, value)
+        while len(params) >= 2:
+            field = params.pop(0)
+            value = params.pop(0)
+            pairs.append((field, value))
+        
+        return pairs
+
+    def _apply_replacements(self, message: str, replacements: Dict[str, str]) -> str:
+        """Safely apply all replacements to the message"""
+        for placeholder, replacement in replacements.items():
+            if replacement is not None:
+                # Use regex to avoid partial replacements
+                message = re.sub(
+                    re.escape(placeholder) + r'(?![a-zA-Z0-9_])', 
+                    str(replacement), 
+                    message
+                )
+        return message
+
+    def _get_other_param_display(self) -> Optional[str]:
+        """Get display names for other fields with proper formatting"""
+        other_fields = self._get_raw_other_fields()
+        if not other_fields:
+            return None
+            
+        display_names = [self._get_attribute_name(f) for f in other_fields]
+        
+        if len(display_names) == 1:
+            return display_names[0]
+        if len(display_names) == 2:
+            return f"{display_names[0]} and {display_names[1]}"
+        return f"{', '.join(display_names[:-1])}, and {display_names[-1]}"
+
+    def _get_raw_other_fields(self) -> List[str]:
+        """Extract field references from rule parameters"""
+        if not self._current_rule or not self._current_params:
+            return []
+            
+        rule = self._current_rule.lower()
+        
+        # Rules with field-value pairs (field1,value1,field2,value2,...)
+        if rule in {
+            'required_if', 'required_unless', 'exclude_if', 'exclude_unless',
+            'missing_if', 'missing_unless', 'present_if', 'present_unless'
+        }:
+            return self._current_params[::2]  # Take every even index
+            
+        # Rules with just field references
+        if rule in {
+            'prohibits', 'exclude_with', 'exclude_without',
+            'missing_with', 'missing_with_all', 
+            'present_with', 'present_with_all'
+        }:
+            return self._current_params
+            
+        # Single field rules
+        if rule in {
+            'required_if_accepted', 'required_if_declined',
+            'prohibited_if_accepted', 'prohibited_if_declined'
+        }:
+            return [self._current_params[0]] if self._current_params else []
+            
+        return []
+
+    def _get_min_param(self) -> Optional[str]:
+        """Get min parameter from rule"""
+        if not self._current_params:
+            return None
+            
+        if self._current_rule and self._current_rule.startswith(('min', 'between', 'digits_between')):
+            return self._current_params[0]
+        return None
+
+    def _get_max_param(self) -> Optional[str]:
+        """Get max parameter from rule"""
+        if not self._current_params or len(self._current_params) < 2:
+            return None
+            
+        if self._current_rule and self._current_rule.startswith(('max', 'between', 'digits_between')):
+            return self._current_params[1] if self._current_rule.startswith('between') else self._current_params[0]
+        return None
+
+    def _get_size_param(self) -> Optional[str]:
+        """Get size parameter from rule"""
+        if self._current_rule and self._current_rule.startswith('size') and self._current_params:
+            return self._current_params[0]
+        return None
+
+    def _get_values_param(self) -> Optional[str]:
+        """Get values list for in/not_in rules"""
+        if (self._current_rule and 
+            self._current_rule.startswith(('in', 'not_in')) and 
+            self._current_params):
+            return ', '.join(self._current_params)
+        return None
+
+    def _get_date_param(self) -> Optional[str]:
+        """Get date parameter for date rules"""
+        if (self._current_rule and 
+            self._current_rule.startswith(('after', 'before', 'after_or_equal', 'before_or_equal')) and 
+            self._current_params):
+            return self._current_params[0]
+        return None
+
+    def _get_format_param(self) -> Optional[str]:
+        """Get format parameter"""
+        if (self._current_rule and 
+            self._current_rule.startswith('date_format') and 
+            self._current_params):
+            return self._current_params[0]
+        return None
+
+    def _get_first_param(self) -> Optional[str]:
+        """Get first parameter from rule"""
+        return self._current_params[0] if self._current_params else None
+
     @property
     def has_errors(self) -> bool:
         """Check if any errors exist"""

safeshield-1.2.1.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=00qVnbH-EJC5KALlaoUBLAfsszAFLcoSxfRbmy0amyk,12751
-validator/database/__init__.py,sha256=O-cB6-MhNapJ3iwe5jvifbMfr1dPjXLtEdfNTKIu0hc,171
-validator/database/detector.py,sha256=Vac7oVL26GjU6expGo01-6mgUtXqldr-jirzpYokZBM,9597
-validator/database/manager.py,sha256=Ezz4NUh22Hz2puh-NJggSGCaw3lAGyp3V88plMeBBVU,6232
-validator/rules/__init__.py,sha256=nDE3qoI82qJTCbILLUWkXuwsMOmsDtB1m-3IGIvRfpY,919
-validator/rules/array.py,sha256=tx8FCDqn-27Vs7tgtjeoCE9ceDMVrdBEb2-pq-lNLuo,2809
-validator/rules/base.py,sha256=hrGESfkdvqZrQ1yIK_ftVVOMUuyvNFoz-_qaqUucSy8,3474
-validator/rules/basic.py,sha256=fMk0s5_IEQu27X1wndP_ocNyOZ1upXJCn7fR9YYbI74,1527
-validator/rules/comparison.py,sha256=9xb2mO5GiThR1iO8867ex2o7olQC2Bnew6MBdD2UtEo,9402
-validator/rules/conditional.py,sha256=8_O1etzCyCGeD8lmfhegJ1uzhkBSjTEVdufbZmkqgP4,12993
-validator/rules/date.py,sha256=18JIKTO5nzFtCnJEMXm4OUbneqTMB7HGPN6jUkxGU4Y,5278
-validator/rules/files.py,sha256=vu_TZFffDPzDojyTsFXSQ6MmQm3WU6ppFfz7-wuDy98,6550
-validator/rules/format.py,sha256=UeeIAkFn0CdzC5bS9tI78_lbPYRgcpaUujxdmyCSdzE,3744
-validator/rules/string.py,sha256=vYzu4ICKY9FCuGahmsQCoJLmnlBF7uNvVazFj9DQ438,3178
-validator/rules/type.py,sha256=Tu-EOBkTtxkcCe0ANXavurZC449n63iE_VXVzc3BIiM,1596
-validator/rules/utilities.py,sha256=AIm9JRGYf6cTCSkivg3gTj3U5DnXlCAJ5ej1yUSa1dU,9724
-validator/services/__init__.py,sha256=zzKTmqL7v4niFGWHJBfWLqgJ0iTaW_69OzYZN8uInzQ,210
-validator/services/rule_conflict.py,sha256=s1RJNUY5d0WtSMHkrKulBCgJ2BZL2GE0Eu5pdAoiIbM,4943
-validator/services/rule_error_handler.py,sha256=MGvvkP6hbZLpVXxC3xpzg15OmVdPlk7l0M2Srmy5VfM,1729
-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.2.1.dist-info/LICENSE,sha256=qugtRyKckyaks6hd2xyxOFSOYM6au1N80pMXuMTPvC4,1090
-safeshield-1.2.1.dist-info/METADATA,sha256=CvKZoic-BfXRql20T5GApMX4WnfD4IO51mFeDLg_asQ,1843
-safeshield-1.2.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-safeshield-1.2.1.dist-info/top_level.txt,sha256=iUtV3dlHOIiMfLuY4pruY00lFni8JzOkQ3Nh1II19OE,10
-safeshield-1.2.1.dist-info/RECORD,,