safeshield 1.2.2__tar.gz → 1.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: safeshield
-Version: 1.2.2
+Version: 1.3.2
 Summary: Library for Help Validation Control
 Home-page: https://github.com/WunsunTarniho/py-guard
 Author: Wunsun Tarniho
@@ -58,3 +58,6 @@ 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.

{safeshield-1.2.2 → safeshield-1.3.2}/README.md

@@ -38,4 +38,7 @@ 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.

{safeshield-1.2.2 → safeshield-1.3.2}/safeshield.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: safeshield
-Version: 1.2.2
+Version: 1.3.2
 Summary: Library for Help Validation Control
 Home-page: https://github.com/WunsunTarniho/py-guard
 Author: Wunsun Tarniho
@@ -58,3 +58,6 @@ 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.

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

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

{safeshield-1.2.2 → safeshield-1.3.2}/validator/core/validator.py

@@ -221,18 +221,18 @@ class Validator:
         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:

{safeshield-1.2.2 → safeshield-1.3.2}/validator/rules/array.py

@@ -19,8 +19,8 @@ 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."
+            return f"The :attribute must contain the keys: {', '.join(self._missing_keys)}."
+        return f"The :attribute must be an array."
 
 class ContainsRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -44,7 +44,7 @@ class ContainsRule(ValidationRule):
         return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must contain {params[0]}"
+        return f"The :attribute must contain {params[0]}"
     
 class DistinctRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -54,7 +54,7 @@ class DistinctRule(ValidationRule):
         return len(value) == len(set(value))
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must contain unique values"
+        return f"The :attribute must contain unique values"
     
 class InArrayRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -64,7 +64,7 @@ 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):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -74,4 +74,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/validator/rules/conditional.py → safeshield-1.3.2/validator/rules/basic.py

@@ -1,234 +1,123 @@
 from .base import ValidationRule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
-from enum import Enum
-import re
-import inspect
-from collections.abc import Iterable
 
 # =============================================
-# CONDITIONAL VALIDATION RULES
+# BASIC VALIDATION RULES
 # =============================================
 
-class RequiredIfRule(ValidationRule):
+class AnyOfRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2 or len(params) % 2 != 0:
-            return True
-            
-        conditions = list(zip(params[::2], params[1::2]))
-        
-        condition_met = False
-        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 not condition_met:
-            return True
-            
-        return not self.is_empty(value)
-    
-    def message(self, field: str, params: List[str]) -> str:
-        valid_conditions = []
-        if len(params) >= 2 and len(params) % 2 == 0:
-            valid_conditions = [
-                f"{params[i]} = {params[i+1]}" 
-                for i in range(0, len(params), 2) 
-                if params[i] and params[i+1] is not None
-            ]
-        
-        if not valid_conditions:
-            return f"Invalid required_if rule configuration for {field}"
-            
-        return f"The :name field is required when any of these are true: {', '.join(valid_conditions)}"
-    
-class RequiredAllIfRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
+        if not params:
             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 not self.is_empty(value)
+        return any(self.get_field_value(param, param) == value for param in params)
     
     def message(self, field: str, params: List[str]) -> str:
-        conditions = " AND ".join(f"{f} = {v}" for f, v in zip(params[::2], params[1::2]))
-        return f"The :name field is required when ALL conditions are met: {conditions}"
+        return f"The :attribute must be one of: {', '.join(params)}"
 
-class RequiredUnlessRule(ValidationRule):
+class BailRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
-            return False
-            
-        other_field, other_value = params[0], params[1]
-        actual_value = self.get_field_value(other_field, '') 
-        
-        if actual_value == other_value:
-            return True
-            
-        return not self.is_empty(value)
+        self.validator._stop_on_first_failure = True
+        return True
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required unless {params[0]} is {params[1]}."
+        return ""
 
-class RequiredWithRule(ValidationRule):
+class RequiredRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
-        if any(f in self.validator.data for f in params):
-            return not self.is_empty(value)
-        return True
+        return not self.is_empty(value)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required when {', '.join(params)} is present."
+        return f"The :attribute field is required."
 
-class RequiredWithAllRule(ValidationRule):
+class ProhibitedRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
-        if all(f in self.validator.data for f in params):
-            return not self.is_empty(value)
-        return True
+        return self.is_empty(value)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required when all of {', '.join(params)} are present."
-
-class RequiredWithoutRule(ValidationRule):
+        return "The :attribute field is must be empty."
+    
+class NullableRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
-        if any(f not in self.validator.data for f in params):
-            return not self.is_empty(value)
         return True
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required when {', '.join(params)} is not present."
+        return f"The :attribute may be null."
 
-class RequiredWithoutAllRule(ValidationRule):
+class FilledRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
-        if all(f not in self.validator.data for f in params):
-            return not self.is_empty(value)
-        return True
+        return value not in ('', None)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required when none of {', '.join(params)} are present."
+        return f"The :attribute field must have a value."
 
-class ProhibitedIfRule(ValidationRule):
+class PresentRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
-            return False
-            
-        other_field, other_value = params[0], params[1]
-        actual_value = self.get_field_value(other_field, '')
-        
-        if actual_value != other_value:
-            return True
-            
-        return self.is_empty(value)
+        return field in self.validator.data
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is prohibited when {params[0]} is {params[1]}."
-
-class ProhibitedUnlessRule(ValidationRule):
+        return f"The :attribute field must be present."
+    
+class MissingRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
-            return False
-            
-        other_field, other_value = params[0], params[1]
-        actual_value = self.get_field_value(other_field, '') 
-        
-        if actual_value == other_value:
-            return True
-            
-        return self.is_empty(value)
+        return value is None
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is prohibited unless {params[0]} is {params[1]}."
-
-class FilledIfRule(ValidationRule):
+        return f"The :attribute field must be missing."
+    
+class ProhibitsRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
-            return False
-            
-        other_field, other_value = params[0], params[1]
-        actual_value = self.get_field_value(other_field, '')
-        
-        if actual_value != other_value:
+        if not params or value is None:
             return True
-            
-        return value not in ('', None)
+        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"The :name field must be filled when {params[0]} is {params[1]}."
-
-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
+        return f"When :attribute is present, {', '.join(params)} must be absent."
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name format is invalid."
-
-class NotRegexRule(ValidationRule):
+class AcceptedRule(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
+        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 :name format is invalid."
+        return f"The :attribute must be accepted."
 
-class InRule(ValidationRule):
+class DeclinedRule(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)
-
+        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:
-        allowed_values = self._parse_option_values(field, params)
-        return f"The selected :name must be in : {', '.join(map(str, allowed_values))}"
+        return f"The :attribute must be declined."
 
-class NotInRule(ValidationRule):
+class SometimesRule(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
+        return True
     
     def message(self, field: str, params: List[str]) -> str:
-        not_allowed_values = self._parse_option_values(field, params)
-        return f"The selected :name must be not in : {', '.join(map(str, not_allowed_values))}"
+        return ""
     
-class EnumRule(ValidationRule):
+class ExcludeRule(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)
-
+        self.validator._is_exclude = True
+        
+        return True
+    
     def message(self, field: str, params: List[str]) -> str:
-        allowed_values = self._parse_option_values(field, params)
-        return f"The :name must be one of: {', '.join(map(str, allowed_values))}"
+        return ""
 
 class UniqueRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -239,7 +128,6 @@ class UniqueRule(ValidationRule):
         column = field if len(params) == 1 else params[1]
         
         try:
-            # Optional: handle ignore case (id)
             ignore_id = None
             if len(params) > 2 and params[2].startswith('ignore:'):
                 ignore_field = params[2].split(':')[1]
@@ -250,7 +138,7 @@ class UniqueRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name has already been taken."
+        return f"The :attribute has already been taken."
 
 class ExistsRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -267,7 +155,7 @@ class ExistsRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The selected :name is invalid."
+        return f"The selected :attribute is invalid."
 
 class ConfirmedRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -276,7 +164,7 @@ class ConfirmedRule(ValidationRule):
         return value == self.get_field_value(confirmation_field, '') 
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name confirmation does not match."
+        return f"The :attribute confirmation does not match."
 
 class SameRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -285,7 +173,7 @@ class SameRule(ValidationRule):
         return value == self.get_field_value(params[0]) 
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name and {params[0]} must match."
+        return f"The :attribute and {params[0]} must match."
 
 class DifferentRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -294,39 +182,56 @@ class DifferentRule(ValidationRule):
         return value != self.get_field_value(params[0]) 
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name and {params[0]} must be different."
-
-class AcceptedRule(ValidationRule):
+        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 isinstance(value, str):
-            return value.lower() in ['yes', 'on', '1', 'true']
-        if isinstance(value, int):
-            return value == 1
-        if isinstance(value, bool):
-            return value
-        return False
+        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 :name must be accepted."
+        return f"The :attribute format is invalid."
 
-class DeclinedRule(ValidationRule):
+class NotRegexRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if isinstance(value, str):
-            return value.lower() in ['no', 'off', '0', 'false']
-        if isinstance(value, int):
-            return value == 0
-        if isinstance(value, bool):
-            return not value
-        return False
+        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 :name must be declined."
+        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)
 
-class BailRule(ValidationRule):
+    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:
-        self.validator._stop_on_first_failure = True
-        return True
+        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:
-        return ""
+        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))}"

{safeshield-1.2.2 → safeshield-1.3.2}/validator/rules/comparison.py

@@ -27,7 +27,7 @@ class MinRule(ValidationRule):
         return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be at least {params[0]}."
+        return f"The :attribute must be at least {params[0]}."
 
 class MaxRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -85,13 +85,13 @@ class MaxRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         value = self.get_field_value(field)
         if value is None:
-            return f"The {field} must not exceed {params[0]}"
+            return f"The :attribute must not exceed {params[0]}"
             
         # Check all possible file size attributes
         file_attrs = ['content_length', 'size', 'fileno']
         if any(hasattr(value, attr) for attr in file_attrs):
-            return f"File {field} must not exceed {params[0]} bytes"
-        return f"The {field} must not exceed {params[0]}"
+            return f"File :attribute must not exceed {params[0]} bytes"
+        return f"The :attribute must not exceed {params[0]}"
 
 class BetweenRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -136,8 +136,8 @@ class BetweenRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         value = self.get_field_value(field)
         if hasattr(value, 'content_length') or hasattr(value, 'size'):
-            return f"File {field} must be between {params[0]} and {params[1]} bytes"
-        return f"The {field} must be between {params[0]} and {params[1]}"
+            return f"File :attribute must be between {params[0]} and {params[1]} bytes"
+        return f"The :attribute must be between {params[0]} and {params[1]}"
 
 class SizeRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -182,14 +182,14 @@ class SizeRule(ValidationRule):
     def message(self, field: str, params: List[str]) -> str:
         value = self.get_field_value(field)
         if value is None:
-            return f"The {field} must be exactly {params[0]}"
+            return f"The :attribute must be exactly {params[0]}"
             
         # Check for file attributes
         file_attrs = ['content_length', 'size', 'fileno']
         if any(hasattr(value, attr) for attr in file_attrs):
-            return f"File {field} must be exactly {params[0]} bytes"
+            return f"File :attribute must be exactly {params[0]} bytes"
             
-        return f"The {field} must be exactly {params[0]}"
+        return f"The :attribute must be exactly {params[0]}"
     
 class DigitsRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -204,7 +204,7 @@ class DigitsRule(ValidationRule):
         return value.isdigit() and len(value) == digits
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be {params[0]} digits."
+        return f"The :attribute must be {params[0]} digits."
 
 class DigitsBetweenRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -220,7 +220,7 @@ class DigitsBetweenRule(ValidationRule):
         return value.isdigit() and min_digits <= len(value) <= max_digits
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be between {params[0]} and {params[1]} digits."
+        return f"The :attribute must be between {params[0]} and {params[1]} digits."
 
 class MultipleOfRule(ValidationRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -237,4 +237,4 @@ class MultipleOfRule(ValidationRule):
             return False
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be a multiple of {params[0]}."
+        return f"The :attribute must be a multiple of {params[0]}."