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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: safeshield
-Version: 1.2.1
+Version: 1.3.2
 Summary: Library for Help Validation Control
 Home-page: https://github.com/WunsunTarniho/py-guard
 Author: Wunsun Tarniho
@@ -63,3 +63,9 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## v1.2.1 (2024-07-20)
 - Fixed: Bug unique and exist rule.
+
+## 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.3.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=bImQNLhEJg5VTxtHiMYVb2EbHWvimTDqHq-UcA8uolw,812
+validator/core/__init__.py,sha256=ZcqlXJSk03i_CVzmIN-nVe1UOyvwwO5jhbEj7f62Y_o,59
+validator/core/validator.py,sha256=Yaw7__Hf-PuKcXaJ6yaARPEyeofEaoqt5-N3tJZ_jtg,12741
+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=nDE3qoI82qJTCbILLUWkXuwsMOmsDtB1m-3IGIvRfpY,919
+validator/rules/array.py,sha256=3hgD_b2K61fG-xT1UdssHMOdIQKWw5vkdpovNn-kc8E,2835
+validator/rules/base.py,sha256=hrGESfkdvqZrQ1yIK_ftVVOMUuyvNFoz-_qaqUucSy8,3474
+validator/rules/basic.py,sha256=rL9THt3OE5QgtuxGCM_dklNpPKOdmuDP30EiSmvkgP8,9656
+validator/rules/comparison.py,sha256=Tlg3AfjTd-W1RonmhT0PLP_mf4CSyhpl7EsmCEYzEAA,9446
+validator/rules/conditional.py,sha256=M4x9g2LQTXNaNfb7dHRMs6vUseDu3WC1RB41QGiNABQ,5965
+validator/rules/date.py,sha256=sPrq8OgHMyUxRAZch4yt7K3I0lInIIy0dUgRtAkcsMk,5313
+validator/rules/files.py,sha256=eCrarOtaRWv1UBQuv5Y6-CcyHuncyLau8V8Ocpw0NVQ,6565
+validator/rules/format.py,sha256=hyho3Cxcgjz4mqCkO_uvjrJPU1JEOK2IZL7F6Dh9oPg,3784
+validator/rules/string.py,sha256=5NToIDOqBhmUYCg1y2y2zdQ4MMLyJzL0FCTM5XhzAgc,2951
+validator/rules/type.py,sha256=B8YH1T1RBlRNNOmb-5uZKdwBc8Uk1Zj4h4xIzAtJC2M,1883
+validator/rules/utilities.py,sha256=xysxDWoP1hJQyBZhNvdzTyMsFOWsEIxFBvYPljW1coA,5340
+validator/services/__init__.py,sha256=zzKTmqL7v4niFGWHJBfWLqgJ0iTaW_69OzYZN8uInzQ,210
+validator/services/rule_conflict.py,sha256=s1RJNUY5d0WtSMHkrKulBCgJ2BZL2GE0Eu5pdAoiIbM,4943
+validator/services/rule_error_handler.py,sha256=MNgSxnakmc3f_nvGuapRmJ9woKt_-E8Wun39OCTrGB0,10273
+validator/services/rule_preparer.py,sha256=jRcMNjqq2xyZjO64Pim8jWmja5DmTzf0V_uuHG0lJTg,5621
+validator/utils/__init__.py,sha256=Yzo-xv285Be-a233M4duDdYtscuHiuBbPSX_C8yViJI,20
+validator/utils/string.py,sha256=0YACzeEaWNEOR9_7O9A8D1ItIbtWfOJ8IfrzcB8VMYA,515
+safeshield-1.3.2.dist-info/LICENSE,sha256=qugtRyKckyaks6hd2xyxOFSOYM6au1N80pMXuMTPvC4,1090
+safeshield-1.3.2.dist-info/METADATA,sha256=V17d3w6UPE698CGSm83-5C3NOm-lZrCqLJYAy8ozrHM,1984
+safeshield-1.3.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+safeshield-1.3.2.dist-info/top_level.txt,sha256=iUtV3dlHOIiMfLuY4pruY00lFni8JzOkQ3Nh1II19OE,10
+safeshield-1.3.2.dist-info/RECORD,,

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:

validator/database/manager.py

@@ -46,7 +46,12 @@ class DatabaseManager:
         self.connect()
         cursor = None
         try:
-            cursor = self.connection.cursor(dictionary=True)
+            if self._connection_params['type'] == 'postgresql':
+                from psycopg2.extras import RealDictCursor
+                cursor = self.connection.cursor(cursor_factory=RealDictCursor)
+            else:
+                cursor = self.connection.cursor(dictionary=True)
+                
             yield cursor
         finally:
             if cursor:

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)}"

validator/rules/basic.py

@@ -5,33 +5,103 @@ from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
 # BASIC VALIDATION RULES
 # =============================================
 
+class AnyOfRule(ValidationRule):
+    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)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :attribute must be one of: {', '.join(params)}"
+
+class BailRule(ValidationRule):
+    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(ValidationRule):
     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 ProhibitedRule(ValidationRule):
+    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):
     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):
     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):
     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(ValidationRule):
+    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):
+    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 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):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
@@ -39,3 +109,129 @@ class SometimesRule(ValidationRule):
     
     def message(self, field: str, params: List[str]) -> str:
         return ""
+    
+class ExcludeRule(ValidationRule):
+    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))}"

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]}."