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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: safeshield
-Version: 1.3.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
@@ -69,3 +71,6 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## 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,7 +217,7 @@ 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)
             
@@ -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:
@@ -21,42 +20,36 @@ class ArrayRule(ValidationRule):
         if params:
             return f"The :attribute must contain the keys: {', '.join(self._missing_keys)}."
         return f"The :attribute must be an array."
-
-class ContainsRule(ValidationRule):
+    
+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 :attribute 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 :attribute 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
@@ -66,7 +59,7 @@ class InArrayRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         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

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,20 +1,63 @@
-from .base import ValidationRule
+from .base import Rule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 
 # =============================================
 # BASIC VALIDATION RULES
 # =============================================
 
-class AnyOfRule(ValidationRule):
+class AnyOfRule(Rule):
     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)
-    
+        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:
-        return f"The :attribute must be one of: {', '.join(params)}"
+        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(ValidationRule):
+class BailRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         self.validator._stop_on_first_failure = True
         return True
@@ -22,49 +65,49 @@ class BailRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         return ""
 
-class RequiredRule(ValidationRule):
+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 :attribute field is required."
 
-class ProhibitedRule(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(ValidationRule):
+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 :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 :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 :attribute field must be present."
     
-class MissingRule(ValidationRule):
+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(ValidationRule):
+class ProhibitsRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params or value is None:
             return True
@@ -72,166 +115,22 @@ class ProhibitsRule(ValidationRule):
     
     def message(self, field: str, params: List[str]) -> str:
         return f"When :attribute is present, {', '.join(params)} must be absent."
-    
-class AcceptedRule(ValidationRule):
-    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(ValidationRule):
-    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 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(ValidationRule):
+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 ""
-
-class UniqueRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or not hasattr(self.validator, 'db_manager') or not self.validator.db_manager:
-            return False
-            
-        table = params[0]
-        column = field if len(params) == 1 else params[1]
-        
-        try:
-            ignore_id = None
-            if len(params) > 2 and params[2].startswith('ignore:'):
-                ignore_field = params[2].split(':')[1]
-                ignore_id = self.get_field_value(ignore_field) 
-            return self.validator.db_manager.is_unique(table, column, value, ignore_id)
-        except Exception as e:
-            print(f"Database error in UniqueRule: {e}")
-            return False
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute has already been taken."
-
-class ExistsRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or not hasattr(self.validator, 'db_manager') or not self.validator.db_manager:
-            return False
-            
-        table = params[0]
-        column = field if len(params) == 1 else params[1]
-        
-        try:
-            return self.validator.db_manager.exists(table, column, value)
-        except Exception as e:
-            print(f"Database error in ExistsRule: {e}")
-            return False
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The selected :attribute is invalid."
-
-class ConfirmedRule(ValidationRule):
-    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 SameRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-        return value == self.get_field_value(params[0]) 
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute and {params[0]} must match."
-
-class DifferentRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-        return value != self.get_field_value(params[0]) 
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute and {params[0]} must be different."
-    
-class RegexRule(ValidationRule):
-    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(ValidationRule):
-    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."
-
-class InRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        allowed_values = self._parse_option_values(field, params)
-        return (str(value) in allowed_values or value in allowed_values)
-
-    def message(self, field: str, params: List[str]) -> str:
-        allowed_values = self._parse_option_values(field, params)
-        return f"The selected :attribute must be in : {', '.join(map(str, allowed_values))}"
-
-class NotInRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        not_allowed_values = self._parse_option_values(field, params)
-        return str(value) not in not_allowed_values
-    
-    def message(self, field: str, params: List[str]) -> str:
-        not_allowed_values = self._parse_option_values(field, params)
-        return f"The selected :attribute must be not in : {', '.join(map(str, not_allowed_values))}"
-    
-class EnumRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        allowed_values = self._parse_option_values(field, params)
-        return (str(value) in allowed_values or value in allowed_values)
-
-    def message(self, field: str, params: List[str]) -> str:
-        allowed_values = self._parse_option_values(field, params)
-        return f"The :attribute must be one of: {', '.join(map(str, allowed_values))}"
+        return ""