safeshield 1.2.2__py3-none-any.whl → 1.4.2__py3-none-any.whl

{safeshield-1.2.2.dist-info → safeshield-1.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: safeshield
-Version: 1.2.2
+Version: 1.4.2
 Summary: Library for Help Validation Control
 Home-page: https://github.com/WunsunTarniho/py-guard
 Author: Wunsun Tarniho
@@ -24,6 +24,8 @@ Requires-Dist: python-dateutil==2.9.0.post0
 Requires-Dist: setuptools==63.2.0
 Requires-Dist: SQLAlchemy==2.0.41
 Requires-Dist: Werkzeug==1.0.1
+Requires-Dist: dnspython==2.4.2
+Requires-Dist: idna==3.4
 
 ## License
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
@@ -66,3 +68,9 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## v1.2.2 (2024-07-20)
 - Fixed: Error when connect use postgres.
+
+## v1.3.2 (2024-07-20)
+- Refinement: Groups Inheritance Rule Class.
+
+## v1.4.2 (2024-07-20)
+- Feature: Rule can accept function as argument, Rule Chaning

safeshield-1.4.2.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=JruOF0Mumk5PPqendNsO5TN4ZmPEGBNS7Nivly4_oUc,772
+validator/core/__init__.py,sha256=ZcqlXJSk03i_CVzmIN-nVe1UOyvwwO5jhbEj7f62Y_o,59
+validator/core/validator.py,sha256=pbfbTu6OvJiqyNu58OnIZI97a8x2r9T25IrWkBMJKTs,12684
+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/boolean.py,sha256=vy6huFJ5JidpsoJ0WSvcydiU7a8aYFj225UswggSGAE,5748
+validator/rules/comparison.py,sha256=xkQ0xoqBjVlDSfgwTvruOAnXUmKlNt9kDjTcG5r4cFM,13473
+validator/rules/date.py,sha256=yolYaTIvQTN1LBje5SM8i7EmNzOxV_eUwnOokmqZrMs,5812
+validator/rules/files.py,sha256=c7deO8fEiFNCx4jq1B2sJXhxTqGzTVq4kK2EscSNhKI,10946
+validator/rules/format.py,sha256=Medw57PJwfElxA-DgxiZ5GHqvqPhUCQPFMGCGTDne8w,7070
+validator/rules/numeric.py,sha256=nkYVc8VtrWJ3Kt7JDLPsbg7ZaN3F0zJMnbf8Y5gxNsk,6824
+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=A9wtjpqAQsz13qUN5sh9wz7d1wc3S3RWms-BcRCECu0,10279
+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.2.dist-info/LICENSE,sha256=qugtRyKckyaks6hd2xyxOFSOYM6au1N80pMXuMTPvC4,1090
+safeshield-1.4.2.dist-info/METADATA,sha256=rQBoOn-D8UTPn31TwaR_h8WStPE0aqtJ9g-x4p6oT3I,2132
+safeshield-1.4.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+safeshield-1.4.2.dist-info/top_level.txt,sha256=iUtV3dlHOIiMfLuY4pruY00lFni8JzOkQ3Nh1II19OE,10
+safeshield-1.4.2.dist-info/RECORD,,

validator/core/validator.py

@@ -2,7 +2,7 @@ from typing import Optional, Dict, Any, List, Tuple, Union
 from validator.exceptions import ValidationException, RuleNotFoundException
 from validator.factory import RuleFactory
 from validator.database import DatabaseManager, DatabaseAutoDetector
-from validator.rules import ValidationRule
+from validator.rules import Rule
 from validator.services.rule_conflict import RuleConflictChecker
 from validator.services.rule_error_handler import RuleErrorHandler
 from validator.services.rule_preparer import RulePreparer
@@ -12,7 +12,7 @@ from collections.abc import Mapping
 class Validator:
     """Main validation class with proper abstractions"""
     PRIORITY_RULES = {
-        'bail', 'exclude_unless', 'exclude_if', 'exclude_with', 'exclude_without', 'required', 'required_if', 'required_unless',
+        'bail', 'sometimes', 'exclude_unless', 'exclude_if', 'exclude_with', 'exclude_without', 'required', 'required_if', 'required_unless',
         'required_with', 'required_without'
     }
 
@@ -23,7 +23,7 @@ class Validator:
             str, 
             List[Union[
                 str, 
-                ValidationRule, 
+                Rule, 
                 Tuple[str, Union[
                     str, 
                     Union[
@@ -38,7 +38,7 @@ class Validator:
             ]],
             Tuple[Union[
                 str, 
-                ValidationRule, 
+                Rule, 
                 Tuple[str, Union[
                     str, 
                     Union[
@@ -94,7 +94,7 @@ class Validator:
             return False
         return True
 
-    def _validate_rules(self, prepared_rules: Dict[str, List[ValidationRule]], priority_only: bool):
+    def _validate_rules(self, prepared_rules: Dict[str, List[Rule]], priority_only: bool):
         validated = []
         for field_pattern, rules in prepared_rules.items():
             concrete_paths = self._resolve_wildcard_paths(field_pattern) if '*' in field_pattern else [field_pattern]
@@ -217,22 +217,22 @@ class Validator:
         
         return _check(self.data, parts)
     
-    def _apply_rule(self, field: str, value: Any, rule: ValidationRule) -> bool:
+    def _apply_rule(self, field: str, value: Any, rule: Rule) -> bool:
         try:
             rule.set_validator(self)
             
-            # Format field name untuk pesan error (otomatis tangkap path aktual)
             display_field = getattr(self, '_current_actual_path', field)
             
             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, msg, value)
+                self.error_handler.add_error(display_field, rule.rule_name, 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, str(e), value)
+            self.error_handler.add_error(display_field, rule.rule_name, getattr(rule, 'params', []), str(e), value)
             return False
 
     def _get_nested_value(self, path: str) -> Any:
@@ -275,7 +275,7 @@ class Validator:
         
         return result
     
-    def add_rule(self, field: str, rules: Union[str, List[Union[str, ValidationRule]], ValidationRule]):
+    def add_rule(self, field: str, rules: Union[str, List[Union[str, Rule]], Rule]):
         """Add new rules to a field"""
         new_rules = self.rule_preparer._convert_to_rules(rules)
         existing_rules = self.rule_preparer._convert_to_rules(self._raw_rules.get(field, []))

validator/factory.py

@@ -1,20 +1,20 @@
 # factory.py
 from typing import Type, Dict, List
 from validator.rules import all_rules
-from validator.rules.base import ValidationRule
+from validator.rules.base import Rule
 
 class RuleFactory:
-    _rules: Dict[str, Type[ValidationRule]] = all_rules
+    _rules: Dict[str, Type[Rule]] = all_rules
     
     @classmethod
-    def create_rule(cls, rule_name: str) -> ValidationRule:
+    def create_rule(cls, rule_name: str) -> Rule:
         try:
             return cls._rules[rule_name]()
         except KeyError:
             raise ValueError(f"Unknown validation rule: {rule_name}")
     
     @classmethod
-    def register_rule(cls, name: str, rule_class: Type[ValidationRule]):
+    def register_rule(cls, name: str, rule_class: Type[Rule]):
         cls._rules[name] = rule_class
         
     @classmethod

validator/rules/__init__.py

@@ -1,16 +1,16 @@
 import inspect
-from .base import ValidationRule
-from . import array, basic, comparison, date, type, files, format, conditional, string, utilities
+from .base import Rule
+from . import array, basic, comparison, date, files, format, boolean, string, numeric, utilities
 
 def _collect_rules():
-    modules = [array, basic, comparison, date, type, files, format, conditional, string, utilities]
+    modules = [array, basic, comparison, date, files, format, boolean, string, numeric, utilities]
     rules = {}
     
     for module in modules:
         for name, obj in inspect.getmembers(module):
             if (inspect.isclass(obj) and 
-                issubclass(obj, ValidationRule) and 
-                obj != ValidationRule):
+                issubclass(obj, Rule) and 
+                obj != Rule):
                 rules[obj.rule_name] = obj
     return rules
 
@@ -21,6 +21,4 @@ for name, cls in all_rules.items():
     globals()[name] = cls  # Export rule name
 
 
-__all__ = ['ValidationRule'] + \
-        list(all_rules.keys()) + \
-        [cls.__name__.replace('Rule', '') for cls in all_rules.values()]
+__all__ = ['Rule'] + [cls.__name__.replace('Rule', '') for cls in all_rules.values()]

validator/rules/array.py

@@ -1,9 +1,8 @@
-from .base import ValidationRule
+from .base import Rule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 
-class ArrayRule(ValidationRule):
+class ArrayRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        
         self._missing_keys = params
         
         if params:
@@ -19,44 +18,38 @@ class ArrayRule(ValidationRule):
 
     def message(self, field: str, params: List[str]) -> str:
         if params:
-            return f"The {field} must contain the keys: {', '.join(self._missing_keys)}."
-        return f"The {field} must be an array."
-
-class ContainsRule(ValidationRule):
+            return f"The :attribute must contain the keys: {', '.join(self._missing_keys)}."
+        return f"The :attribute must be an array."
+    
+class DistinctRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
+        if not isinstance(value, (list, tuple, set)):
             return False
             
-        search_value = params[0]
+        ignore_case = 'ignore_case' in params
         
-        # String contains substring
-        if isinstance(value, str):
-            return search_value in value
-            
-        # Array contains element
-        if isinstance(value, (list, tuple, set)):
-            return search_value in value
+        seen = set()
+        for item in value:
+            compare_val = item
             
-        # Dictionary contains key
-        if isinstance(value, dict):
-            return search_value in value.keys()
+            if ignore_case and isinstance(item, str):
+                compare_val = item.lower()
             
-        return False
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must contain {params[0]}"
-    
-class DistinctRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not isinstance(value, (list, tuple, set)):
-            return False
+            if compare_val in seen:
+                return False
+            seen.add(compare_val)
             
-        return len(value) == len(set(value))
+        return True
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must contain unique values"
+        base_msg = f"The :attribute must contain unique values"
+        
+        if 'ignore_case' in params:
+            return f"{base_msg} (case insensitive)"
+        else:
+            return f"{base_msg} (strict comparison)"
     
-class InArrayRule(ValidationRule):
+class InArrayRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
@@ -64,9 +57,9 @@ class InArrayRule(ValidationRule):
         return str(value) in params
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be one of: {', '.join(params)}"
+        return f"The :attribute must be one of: {', '.join(params)}"
     
-class InArrayKeysRule(ValidationRule):
+class InArrayKeysRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params or not isinstance(value, dict):
             return False
@@ -74,4 +67,4 @@ class InArrayKeysRule(ValidationRule):
         return any(key in value for key in params)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must contain at least one of these keys: {', '.join(params)}"
+        return f"The :attribute must contain at least one of these keys: {', '.join(params)}"

validator/rules/base.py

@@ -1,24 +1,47 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 from enum import Enum
-# from .string import pascal_to_snake
 import inspect
 import re
 
-class ValidationRule(ABC):
+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):
-        cls.rule_name = cls.pascal_to_snake(cls.__name__)
+    def __init_subclass__(cls, name=None):
+        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) -> List[str]:
-        return self._params
+    def params(self):
+        params = []
+        for rule_set in self._params:
+            if isinstance(rule_set, (list, tuple)):
+                params.append(tuple(rule_set))
+            else:
+                params.append(rule_set)
+        return tuple(params)
     
+    @classmethod
+    def _generate_rule_methods(cls):
+        for rule_name, rule_class in cls._rule_classes.items():
+            @classmethod
+            def method(cls, *params, rule_class=rule_class):
+                return rule_class(*params)
+            
+            setattr(cls.__class__, rule_name, method)
+            
     @params.setter
     def params(self, value: List[str]) -> None:
         self._params = value
@@ -64,9 +87,10 @@ class ValidationRule(ABC):
         """Return the name of the rule for error messages."""
         pass
     
-    def _parse_option_values(self, field: str, params: List[str]) -> List[Any]:
+    def _parse_option_values(self, field: str, params: List[str], raise_for_error=True) -> List[Any]:
         """Parse parameters into allowed values, supporting both Enum class and literal values"""
-        if not params:
+        
+        if not params and raise_for_error:
             raise ValueError(
                 f"{self.rule_name} rule requires parameters. "
                 f"Use '({self.rule_name}, EnumClass)' or '{self.rule_name}:val1,val2'"

validator/rules/basic.py

@@ -1,41 +1,136 @@
-from .base import ValidationRule
+from .base import Rule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 
 # =============================================
 # BASIC VALIDATION RULES
 # =============================================
 
-class RequiredRule(ValidationRule):
+class AnyOfRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        self._last_failed_rules = []  # Reset failed rules
+        
+        for i, rule_set in enumerate(params):
+            if isinstance(rule_set, str):
+                rule_set = [rule_set]
+            
+            from validator import Validator
+            
+            temp_validator = Validator(
+                {field: value},
+                {field: rule_set},
+                db_config=getattr(self._validator, 'db_config', None)
+            )
+            
+            if temp_validator.validate():
+                return True
+            else:
+                self._last_failed_rules.append({
+                    'rules': rule_set,
+                    'errors': temp_validator.errors.get(field, [])
+                })
+                
+        return False
+        
+    def message(self, field: str, params: List[str]) -> str:
+        if not self._last_failed_rules:
+            return f"The :attribute field is invalid."
+        
+        error_messages = []
+        
+        for i, failed in enumerate(self._last_failed_rules, 1):
+            rules_str = "|".join(
+                r if isinstance(r, str) else getattr(r, 'rule_name', str(r))
+                for r in failed['rules']
+            )
+            
+            sub_errors = []
+            for j, err_msg in enumerate(failed['errors'], 1):
+                sub_errors.append(f"  {j}. {err_msg}")
+            
+            error_messages.append(
+                f"Option {i} (Rules: {rules_str}):\n" + 
+                "\n".join(sub_errors)
+            )
+        
+        return (
+            f"The :attribute must satisfy at least one of these conditions:\n" +
+            "\n".join(error_messages)
+        )
+
+class BailRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        self.validator._stop_on_first_failure = True
+        return True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return ""
+
+class RequiredRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         return not self.is_empty(value)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required."
+        return f"The :attribute field is required."
 
-class NullableRule(ValidationRule):
+class ProhibitedRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        return self.is_empty(value)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return "The :attribute field is must be empty."
+    
+class NullableRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         return True
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name may be null."
+        return f"The :attribute may be null."
 
-class FilledRule(ValidationRule):
+class FilledRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         return value not in ('', None)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must have a value."
+        return f"The :attribute field must have a value."
 
-class PresentRule(ValidationRule):
+class PresentRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         return field in self.validator.data
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be present."
+        return f"The :attribute field must be present."
+    
+class MissingRule(Rule):
+    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 :attribute field must be missing."
+    
+class ProhibitsRule(Rule):
+    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 :attribute is present, {', '.join(params)} must be absent."
 
-class SometimesRule(ValidationRule):
+class SometimesRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if value is None:
+            self.validator._is_exclude = True
+            
         return True
     
     def message(self, field: str, params: List[str]) -> str:
         return ""
+    
+class ExcludeRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        self.validator._is_exclude = True
+        
+        return True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return ""

validator/rules/boolean.py

@@ -0,0 +1,157 @@
+from .base import Rule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+
+class BooleanRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if isinstance(value, bool):
+            return True
+        if isinstance(value, str):
+            return value.lower() in ['true', 'false', '1', '0', 'yes', 'no', 'on', 'off']
+        if isinstance(value, int):
+            return value in [0, 1]
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute field must be true or false."
+    
+class AcceptedRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        value = self.get_field_value(value, value)
+        
+        if isinstance(value, str):
+            return value.lower() in ['yes', 'on', '1', 1, True, 'true', 'True']
+        if isinstance(value, int):
+            return value == 1
+        if isinstance(value, bool):
+            return value
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be accepted."
+
+class DeclinedRule(Rule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        value = self.get_field_value(value, value)
+        
+        if isinstance(value, str):
+            return value.lower() in ['no', 'off', '0', 0, False, 'false', 'False']
+        if isinstance(value, int):
+            return value == 0
+        if isinstance(value, bool):
+            return not value
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be declined."
+    
+class AcceptedIfRule(AcceptedRule):
+    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 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
+    
+class AcceptedUnlessRule(AcceptedRule):
+    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 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])]
+        
+        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 DeclinedIfRule(DeclinedRule):
+    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 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
+    
+class DeclinedUnlessRule(DeclinedRule):
+    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 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
+        )
+        
+        if not all_conditions_met:
+            return True
+            
+        return super().validate(field, value, params)