safeshield 1.2.2__tar.gz → 1.4.2__tar.gz

{safeshield-1.2.2 → safeshield-1.4.2}/PKG-INFO

@@ -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
@@ -58,3 +58,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.2.2 → safeshield-1.4.2}/README.md

@@ -38,4 +38,10 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 - Fixed: Bug unique and exist rule.
 
 ## v1.2.2 (2024-07-20)
-- Fixed: Error when connect use postgres.
+- 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.2.2 → safeshield-1.4.2}/safeshield.egg-info/PKG-INFO

@@ -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
@@ -58,3 +58,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.2.2 → safeshield-1.4.2}/safeshield.egg-info/SOURCES.txt

@@ -18,13 +18,13 @@ validator/rules/__init__.py
 validator/rules/array.py
 validator/rules/base.py
 validator/rules/basic.py
+validator/rules/boolean.py
 validator/rules/comparison.py
-validator/rules/conditional.py
 validator/rules/date.py
 validator/rules/files.py
 validator/rules/format.py
+validator/rules/numeric.py
 validator/rules/string.py
-validator/rules/type.py
 validator/rules/utilities.py
 validator/services/__init__.py
 validator/services/rule_conflict.py

{safeshield-1.2.2 → safeshield-1.4.2}/safeshield.egg-info/requires.txt

@@ -6,3 +6,5 @@ python_dateutil==2.9.0.post0
 setuptools==63.2.0
 SQLAlchemy==2.0.41
 Werkzeug==1.0.1
+dnspython==2.4.2
+idna==3.4

{safeshield-1.2.2 → safeshield-1.4.2}/setup.py

@@ -7,7 +7,7 @@ def get_requirements():
 
 setup(
     name="safeshield",  # Nama package di PyPI
-    version="1.2.2",
+    version="1.4.2",
     packages=find_packages(),
     install_requires=get_requirements(),
     author="Wunsun Tarniho",

{safeshield-1.2.2 → safeshield-1.4.2}/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, []))

{safeshield-1.2.2 → safeshield-1.4.2}/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

safeshield-1.4.2/validator/rules/__init__.py

@@ -0,0 +1,24 @@
+import inspect
+from .base import Rule
+from . import array, basic, comparison, date, files, format, boolean, string, numeric, utilities
+
+def _collect_rules():
+    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, Rule) and 
+                obj != Rule):
+                rules[obj.rule_name] = obj
+    return rules
+
+all_rules = _collect_rules()
+
+for name, cls in all_rules.items():
+    globals()[cls.__name__.replace('Rule', '')] = cls  # Export class name
+    globals()[name] = cls  # Export rule name
+
+
+__all__ = ['Rule'] + [cls.__name__.replace('Rule', '') for cls in all_rules.values()]

{safeshield-1.2.2 → safeshield-1.4.2}/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)}"

{safeshield-1.2.2 → safeshield-1.4.2}/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'"

safeshield-1.4.2/validator/rules/basic.py

@@ -0,0 +1,136 @@
+from .base import Rule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+
+# =============================================
+# BASIC VALIDATION RULES
+# =============================================
+
+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 :attribute field is required."
+
+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 :attribute may be null."
+
+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(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(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(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 ""

safeshield-1.4.2/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)