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

{safeshield-1.4.3.dist-info → safeshield-1.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: safeshield
-Version: 1.4.3
+Version: 1.4.5
 Summary: Library for Help Validation Control
 Home-page: https://github.com/WunsunTarniho/py-guard
 Author: Wunsun Tarniho
@@ -77,3 +77,9 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## v1.4.3 (2024-07-20)
 - Fixed: Error when validation failed
+
+## v1.4.3 (2024-07-20)
+- Fixed: Sometimes rule failed
+
+## v1.4.4 (2024-07-20)
+- Fixed: Sometimes rule failed

{safeshield-1.4.3.dist-info → safeshield-1.4.5.dist-info}/RECORD

@@ -2,14 +2,14 @@ validator/__init__.py,sha256=udxDzUicPfxBOAQvzsnl3pHur9VUppKbWMgg35hpiww,244
 validator/exceptions.py,sha256=y2v7CaXmeGFHWcnigtLl4U-sFta_jMiXkGKXWIIVglY,366
 validator/factory.py,sha256=JruOF0Mumk5PPqendNsO5TN4ZmPEGBNS7Nivly4_oUc,772
 validator/core/__init__.py,sha256=ZcqlXJSk03i_CVzmIN-nVe1UOyvwwO5jhbEj7f62Y_o,59
-validator/core/validator.py,sha256=pbfbTu6OvJiqyNu58OnIZI97a8x2r9T25IrWkBMJKTs,12684
+validator/core/validator.py,sha256=la-kzp82iCii2bq4hV76F-7datWPb27vmyHvpg2itR0,12726
 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=AqVoBR_chSqxPec14Av5KmR9NAByovXDNNu2oeId4-U,2528
-validator/rules/base.py,sha256=PadT5Ko3Zs_yr5EPxOfTw-IdS7uJKhGpaekF1k4tvYk,4359
-validator/rules/basic.py,sha256=GFdffZKW3Dzw7EOeZTyF1Oma59ZMo9zNK4gddkUMMc4,4892
+validator/rules/base.py,sha256=LWOSigqnn65wges6HjpHEpyoYyDJhbBSabm96t8CXEs,4388
+validator/rules/basic.py,sha256=LWYs4fPCA6_lTtOmtTgvjGqjVxxSdklj9fsCgSAMy2Y,4918
 validator/rules/boolean.py,sha256=vy6huFJ5JidpsoJ0WSvcydiU7a8aYFj225UswggSGAE,5748
 validator/rules/comparison.py,sha256=xkQ0xoqBjVlDSfgwTvruOAnXUmKlNt9kDjTcG5r4cFM,13473
 validator/rules/date.py,sha256=yolYaTIvQTN1LBje5SM8i7EmNzOxV_eUwnOokmqZrMs,5812
@@ -19,13 +19,13 @@ validator/rules/numeric.py,sha256=nkYVc8VtrWJ3Kt7JDLPsbg7ZaN3F0zJMnbf8Y5gxNsk,68
 validator/rules/string.py,sha256=p8ZQfd0XaWIjksg_8ta3f6PEnXlxjRzlSJx1GohZ7yk,5237
 validator/rules/utilities.py,sha256=ns52WbIMTt6Gs85y9kwbTfBjhmX4cfNPwA5Uw6mTaT0,11924
 validator/services/__init__.py,sha256=zzKTmqL7v4niFGWHJBfWLqgJ0iTaW_69OzYZN8uInzQ,210
-validator/services/rule_conflict.py,sha256=JVOgZWIGOviTfcCC69sQ1Bq8nzwtW0UFOx-bbF35uTM,4923
-validator/services/rule_error_handler.py,sha256=0GoBZp12efTY1atu0MKpCXAyDWm_8DYSDrcqfjB6LM8,10415
+validator/services/rule_conflict.py,sha256=T3IhWLmZsRUccJ4oFO-OKRjrc5Xt7r71kktxjjj2IA8,9505
+validator/services/rule_error_handler.py,sha256=K6vq-pdVd5e4Xw7cpTguORy3VPWUJQa3PoeZZcDwTY8,10643
 validator/services/rule_preparer.py,sha256=4khRjdely_0Z5mxFwf1bKIid076_xDuNh2XBO_fGerE,4706
 validator/utils/__init__.py,sha256=Yzo-xv285Be-a233M4duDdYtscuHiuBbPSX_C8yViJI,20
 validator/utils/string.py,sha256=0YACzeEaWNEOR9_7O9A8D1ItIbtWfOJ8IfrzcB8VMYA,515
-safeshield-1.4.3.dist-info/LICENSE,sha256=qugtRyKckyaks6hd2xyxOFSOYM6au1N80pMXuMTPvC4,1090
-safeshield-1.4.3.dist-info/METADATA,sha256=F0LL5L_zO7VDQfciVKDMKX7ka_D1RBOp5UyjfDsukNY,2197
-safeshield-1.4.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-safeshield-1.4.3.dist-info/top_level.txt,sha256=iUtV3dlHOIiMfLuY4pruY00lFni8JzOkQ3Nh1II19OE,10
-safeshield-1.4.3.dist-info/RECORD,,
+safeshield-1.4.5.dist-info/LICENSE,sha256=qugtRyKckyaks6hd2xyxOFSOYM6au1N80pMXuMTPvC4,1090
+safeshield-1.4.5.dist-info/METADATA,sha256=57CDuVbaonpjdkkMIPsptAWIxn5_TKP7zCWzJM8bBiU,2313
+safeshield-1.4.5.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+safeshield-1.4.5.dist-info/top_level.txt,sha256=iUtV3dlHOIiMfLuY4pruY00lFni8JzOkQ3Nh1II19OE,10
+safeshield-1.4.5.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_unless', 'exclude_if', 'exclude_with', 'exclude_without', 'required', 'required_if', 'required_unless',
+        'bail', 'sometimes', 'exclude', 'exclude_unless', 'exclude_if', 'exclude_with', 'exclude_without', 'required', 'required_if', 'required_unless',
         'required_with', 'required_without'
     }
 
@@ -61,7 +61,8 @@ class Validator:
         self.data = data or {}
         self._raw_rules = rules or {}
         self._stop_on_first_failure = False
-        self._is_exclude = False
+        self._field_to_exclude = []
+        
         
         # Initialize dependencies
         self.rule_preparer = RulePreparer(RuleFactory())
@@ -119,7 +120,7 @@ class Validator:
                     )
                     
                 for rule in rules:
-                    if priority_only == (rule.rule_name in self.PRIORITY_RULES) and not self._is_exclude:
+                    if priority_only == (rule.rule_name in self.PRIORITY_RULES):
                         rule.set_field_exists(field_exists)
                         
                         # Skip validation for empty array with wildcard unless it's a required rule
@@ -127,10 +128,10 @@ class Validator:
                             continue
                             
                         for value in values_to_validate:
-                            validated.append(self._apply_rule(field_pattern, value, rule))
+                            if field_pattern not in self._field_to_exclude:
+                                validated.append(self._apply_rule(field_pattern, value, rule))
                 
                 delattr(self, '_current_actual_path')
-            self._is_exclude = False
                 
         return all(valid for valid in validated)
     

validator/rules/base.py

@@ -16,6 +16,7 @@ class Rule(ABC):
         
     def __init_subclass__(cls, name=None):
         cls.rule_name = cls.pascal_to_snake(cls.__name__) if not hasattr(cls, '_name') else cls._name
+        print(cls.__name__)
         cls._register_rule_class()
         cls._generate_rule_methods()
     

validator/rules/basic.py

@@ -119,7 +119,7 @@ class ProhibitsRule(Rule):
 class SometimesRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if value is None:
-            self.validator._is_exclude = True
+            self.validator._field_to_exclude.append(field)
             
         return True
     
@@ -128,7 +128,7 @@ class SometimesRule(Rule):
     
 class ExcludeRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        self.validator._is_exclude = True
+        self.validator._field_to_exclude.append(field)
         
         return True
     

validator/services/rule_conflict.py

@@ -4,70 +4,154 @@ 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'),
+        ('required', 'nullable'),      # Cannot be both mandatory and optional
+        ('required', 'sometimes'),     # Sometimes overrides required
+        ('filled', 'prohibited'),      # Cannot require and prohibit simultaneously
+        ('present', 'missing'),        # Field can't be both present and missing
+        ('accepted', 'declined'),      # Values must be opposite
+        ('same', 'different'),         # Direct logical opposites
         
-        # Type conflicts
-        ('numeric', 'email'),
+        ('required', 'nullable'),      # Cannot be both mandatory and optional
+        ('required', 'sometimes'),     # Sometimes overrides required
+        ('filled', 'prohibited'),      # Cannot require and prohibit simultaneously
+        ('present', 'missing'),        # Field can't be both present and missing
+        ('accepted', 'declined'),      # Values must be opposite
+        ('same', 'different'),         # Direct logical opposites
+        
+        # Numeric vs Other Types
         ('numeric', 'array'),
-        ('boolean', 'integer'),
-        ('boolean', 'numeric'),
-        ('array', 'string'),
+        ('numeric', 'boolean'),
+        ('numeric', 'email'),
+        ('numeric', 'date'),
+        
+        # String vs Other Types
+        ('string', 'array'),
+        ('string', 'file'),
+        ('string', 'json'),
         
-        # Format conflicts
+        # Special Types
+        ('boolean', 'integer'),
+        ('file', 'image'),            # All images are files but not vice versa
+        ('uuid', 'ulid'),             # Similar but incompatible formats
+        ('hex', 'alpha_num'),   
+            
+        # Email/URL/IP Conflicts
         ('email', 'ip'),
-        ('uuid', 'ulid'),
-        ('json', 'timezone'),
+        ('email', 'url'),
+        ('url', 'json'),
+        
+        # Date/Time Conflicts
+        ('date', 'timezone'),
+        ('date_format', 'date_equals'),
+        ('after', 'before'),          # Illogical date ranges
+        
+        # Special Formats
+        ('regex', 'not_regex'),       # Direct pattern negation
+        ('ascii', 'alpha_dash'),      # ASCII vs extended charset
+        ('uppercase', 'lowercase'),   # Case transformation conflicts
+        
+        # Direct Value Checks
+        ('in', 'not_in'),
+        ('starts_with', 'doesnt_start_with'),
+        ('ends_with', 'doesnt_end_with'),
+        
+        # Range Conflicts
+        ('between', 'digits_between'),
+        ('min', 'gt'),
+        ('max', 'lt'),
+        ('size', 'max_digits'),
+        
+        # Numeric Constraints
+        ('multiple_of', 'digits_between'),
+        ('integer', 'decimal'),
+        
+        # Required Group
+        ('required_if', 'exclude_if'),
+        ('required_unless', 'exclude_unless'),
+        
+        # Presence Group
+        ('present_if', 'missing_if'),
+        ('present_unless', 'missing_unless'),
+        
+        # Acceptance Group
+        ('accepted_if', 'declined_if'),
+        ('accepted_unless', 'declined_unless'),
         
-        # Value requirement conflicts
-        ('accepted', 'declined'),
-        ('same', 'different')
+        # Prohibited Group
+        ('prohibited_if', 'required_if'),
+        ('prohibited_unless', 'required_unless'),
+        
+        ('file', 'dimensions'),       # Dimensions only for images
+        ('image', 'mime_types'),
+        ('extensions', 'mimes'),
+        ('file', 'json'),             # Can't be both file and JSON
+        
+        ('array', 'distinct'),        # Distinct requires array
+        ('in_array', 'contains'),     # Similar containment checks
+        ('array_keys', 'in_array'),
     ]
     
-    # Daftar konflik fungsional yang hanya memunculkan warning
     WARNING_CONFLICTS = [
-        # Overlapping validation
-        ('between', 'digits_between'),
-        ('min', 'size'),
-        ('max', 'size'),
-        ('confirmed', 'same'),
-        ('in', 'not_in'),
+        ('integer', 'numeric'),          # integer implies numeric check
+        ('digits', 'digits_between'),    # digits:5 is same as digits_between:5,5
+        ('decimal', 'numeric'),          # decimal is subset of numeric
+        ('multiple_of', 'numeric'),      # multiple_of requires numeric
+        ('min', 'gt'),         # similar lower-bound checks
+        ('max', 'lt'),            # similar upper-bound checks
+        ('digits_between', 'between'),   # overlapping digit vs value ranges
         
-        # Redundant type checks
-        ('integer', 'numeric'),
-        ('alpha_num', 'alpha_dash'),
-        ('starts_with', 'ends_with'),
+        ('alpha', 'alpha_num'),          # alpha_num includes alpha
+        ('alpha_dash', 'alpha_num'),     # alpha_dash extends alpha_num
+        ('ascii', 'alpha'),              # alpha implies ASCII
+        ('uppercase', 'lowercase'),      # mutually exclusive cases
+        ('starts_with', 'ends_with'),    # potentially redundant patterns
+        ('regex', 'ascii'),              # regex might duplicate ASCII check
+        ('contains', 'in_array'),        # similar containment checks
         
-        # Similar format checks
-        ('url', 'json'),
-        ('ulid', 'uuid')
+        ('after', 'after_or_equal'),     # _or_equal is more inclusive
+        ('before', 'before_or_equal'),   # _or_equal is more inclusive
+        ('date_format', 'date'),         # date implies format validation
+        ('timezone', 'date_format'),     # timezone implies format
+        ('date_equals', 'after_or_equal'),  # potential overlap
+        
+        ('file', 'image'),               # image implies file check
+        ('mime_types', 'mime_type_by_extension'),  # similar type checks
+        ('dimensions', 'image'),         # dimensions requires image
+        
+        ('array', 'distinct'),           # distinct requires array
+        ('in_array', 'contains'),        # similar element checks
+        ('array_keys', 'in_array'),      # similar key existence checks
+        
+        ('required_if', 'required_with'),        # similar conditional logic
+        ('prohibited_if', 'prohibited_unless'),  # inverse conditions
+        ('present_with', 'missing_with'),        # mutually aware rules
+        
+        ('string', 'alpha'),            # string conversion implied
+        ('numeric', 'integer'),         # numeric conversion implied
+        ('boolean', 'accepted'),        # boolean conversion implied
     ]
     
-    # Grup rules yang saling terkait
     REQUIRED_GROUPS = {
-        'required_with', 'required_with_all',
-        'required_without', 'required_without_all'
+        'required_if', 'required_unless', 'required_with', 'required_with_all',
+        'required_without', 'required_without_all', 'required_if_accepted', 'required_if_declined'
     }
-    
+
     PROHIBITED_GROUPS = {
-        'prohibited_if', 'prohibited_unless'
+        'prohibited_if', 'prohibited_unless', 'prohibited_if_accepted', 'prohibited_if_declined'
+    }
+
+    EXCLUSION_GROUPS = {
+        'exclude_if', 'exclude_unless', 'exclude_with', 'exclude_without'
+    }
+
+    PRESENCE_GROUPS = {
+        'present_if', 'present_unless', 'present_with', 'present_with_all',
+        'missing_if', 'missing_unless', 'missing_with', 'missing_with_all'
     }
 
     @classmethod
     def check_conflicts(cls, rules: List['Rule']) -> None:
-        """Main method untuk mengecek semua jenis konflik.
-        
-        Args:
-            rules: List of Rule 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}
         

validator/services/rule_error_handler.py

@@ -162,12 +162,15 @@ class RuleErrorHandler:
         # Rules with field-value pairs (field1,value1,field2,value2,...)
         if rule in {
             'required_if', 'required_unless', 'exclude_if', 'exclude_unless',
+            'accepted_if', 'accepted_all_if', 'declined_if', 'declined_all_if',
+            'accepted_unless', 'declined_unless',
             'missing_if', 'missing_unless', 'present_if', 'present_unless'
         }:
             return self._current_params[::2]  # Take every even index
             
-        # Rules with just field references
+        # Rules with multi field references
         if rule in {
+            'required_with', 'required_with_all', 'required_without', 'required_without_all',
             'prohibits', 'exclude_with', 'exclude_without',
             'missing_with', 'missing_with_all', 
             'present_with', 'present_with_all'