osbot-utils 2.81.0__py3-none-any.whl → 2.82.0__py3-none-any.whl

osbot_utils/type_safe/type_safe_core/methods/Type_Safe__Method.py

@@ -2,6 +2,7 @@ import collections
 import inspect                                                                                                                       # For function introspection
 from enum                                                                     import Enum
 from typing                                                                   import get_args, get_origin, Union, List, Any, Dict    # For type hinting utilities
+from osbot_utils.type_safe.Type_Safe__Primitive                               import Type_Safe__Primitive
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
 
 
@@ -18,24 +19,53 @@ class Type_Safe__Method:
                 raise ValueError(f"Parameter '{param_name}' uses lowercase 'any' instead of 'Any' from typing module. "
                                 f"Please use 'from typing import Any' and annotate as '{param_name}: Any'")
 
-    def handle_type_safety(self, args: tuple, kwargs: dict):                              # Main method to handle type safety
+    def convert_primitive_parameters(self, bound_args):         # Convert parameters to Type_Safe__Primitive types where applicable
+
+        for param_name, param_value in bound_args.arguments.items():
+            if param_name == 'self' or param_name not in self.annotations:
+                continue
+
+            expected_type = self.annotations[param_name]
+
+            if not (isinstance(expected_type, type) and issubclass(expected_type, Type_Safe__Primitive)):           # Check if expected type is a Type_Safe__Primitive subclass
+                continue
+
+            primitive_base = expected_type.__primitive_base__                                                       # Try direct conversion for common cases
+
+            if primitive_base in (int, float) and isinstance(param_value, str):                                     # Handle string to int/float conversion
+                try:
+                    bound_args.arguments[param_name] = expected_type(param_value)
+                    continue
+                except (ValueError, TypeError):
+                    pass                                                                                            # Let normal validation handle the error
+
+            if primitive_base and isinstance(param_value, primitive_base):                                          # Handle values that match the primitive base type
+                try:
+                    bound_args.arguments[param_name] = expected_type(param_value)
+                except (ValueError, TypeError):
+                    pass                                                                                            # Let normal validation handle the error
+
+    def handle_type_safety(self, args: tuple, kwargs: dict):                                # Main method to handle type safety
         self.check_for_any_use()
-        bound_args = self.bind_args(args, kwargs)                                         # Bind arguments to parameters
-        for param_name, param_value in bound_args.arguments.items():                      # Iterate through arguments
-            if param_name != 'self':                                                      # Skip self parameter
-                self.validate_parameter(param_name, param_value, bound_args)              # Validate each parameter
-        return bound_args                                                                 # Return bound arguments
-
-    def bind_args(self, args: tuple, kwargs: dict):                                       # Bind args to parameters
-        bound_args = self.sig.bind(*args, **kwargs)                                       # Bind arguments to signature
-        bound_args.apply_defaults()                                                       # Apply default values
-        return bound_args                                                                 # Return bound arguments
-
-    def validate_parameter(self, param_name: str, param_value: Any, bound_args):          # Validate a single parameter
-        self.validate_immutable_parameter(param_name, param_value)                        # Validata the param_value (make sure if it set it is on of IMMUTABLE_TYPES)
-        if param_name in self.annotations:                                                # Check if parameter is annotated
-            expected_type = self.annotations[param_name]                                  # Get expected type
-            self.check_parameter_value(param_name, param_value, expected_type, bound_args)# Check value against type
+        bound_args = self.bind_args(args, kwargs)                                           # Bind arguments to parameters
+
+        self.convert_primitive_parameters(bound_args)                                       # Pre-process primitive type conversions
+
+        for param_name, param_value in bound_args.arguments.items():                        # Iterate through arguments
+            if param_name != 'self':                                                        # Skip self parameter
+                self.validate_parameter(param_name, param_value, bound_args)                # Validate each parameter
+        return bound_args                                                                   # Return bound arguments
+
+    def bind_args(self, args: tuple, kwargs: dict):                                         # Bind args to parameters
+        bound_args = self.sig.bind(*args, **kwargs)                                         # Bind arguments to signature
+        bound_args.apply_defaults()                                                         # Apply default values
+        return bound_args                                                                   # Return bound arguments
+
+    def validate_parameter(self, param_name: str, param_value: Any, bound_args):            # Validate a single parameter
+        self.validate_immutable_parameter(param_name, param_value)                          # Validata the param_value (make sure if it set it is on of IMMUTABLE_TYPES)
+        if param_name in self.annotations:                                                  # Check if parameter is annotated
+            expected_type = self.annotations[param_name]                                    # Get expected type
+            self.check_parameter_value(param_name, param_value, expected_type, bound_args)  # Check value against type
 
     def validate_immutable_parameter(self, param_name, param_value):
         param = self.sig.parameters.get(param_name)      # Check if this is a default value from a mutable type

osbot_utils/version

@@ -1 +1 @@
-v2.81.0
+v2.82.0

{osbot_utils-2.81.0.dist-info → osbot_utils-2.82.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.81.0
+Version: 2.82.0
 Summary: OWASP Security Bot - Utils
 License: MIT
 Author: Dinis Cruz
@@ -21,7 +21,7 @@ Description-Content-Type: text/markdown
 
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.81.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.82.0-blue)
 ![Python](https://img.shields.io/badge/python-3.8+-green)
 ![Type-Safe](https://img.shields.io/badge/Type--Safe-✓-brightgreen)
 ![Caching](https://img.shields.io/badge/Caching-Built--In-orange)

{osbot_utils-2.81.0.dist-info → osbot_utils-2.82.0.dist-info}/RECORD

@@ -417,7 +417,7 @@ osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Tuple.py,sha256=Kx7C
 osbot_utils/type_safe/type_safe_core/collections/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/type_safe_core/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/type_safe_core/decorators/type_safe.py,sha256=wOTMvZBl5hWMz-HuIRZpPBGN0oSbXWd9wH5xxZkfLlA,1796
-osbot_utils/type_safe/type_safe_core/methods/Type_Safe__Method.py,sha256=U2YW4qT7T_w14ohLekRYGYXti1ygm9JfUhayeoG6g10,20192
+osbot_utils/type_safe/type_safe_core/methods/Type_Safe__Method.py,sha256=2xW4x3Hy_g3-Fs5rqyOWPHsmb8pBIqMG1iRe0qjjKW0,22154
 osbot_utils/type_safe/type_safe_core/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/type_safe_core/methods/type_safe_property.py,sha256=DcJkOIs6swJtkglsZVKLyFSczCGSJISOVwAmvjCOQvo,1425
 osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Annotations.py,sha256=kabSiRPYPjpMBJxfjDB5AFRTx-hX17tOznZAd_qQID4,1147
@@ -469,8 +469,8 @@ osbot_utils/utils/Toml.py,sha256=grjWkVPIMVkawJ499FVIJKxQp8FJ2wcsd0Z3YIR4drM,114
 osbot_utils/utils/Version.py,sha256=Ww6ChwTxqp1QAcxOnztkTicShlcx6fbNsWX5xausHrg,422
 osbot_utils/utils/Zip.py,sha256=mG42lgTY0tnm14T3P1-DSAIZKkTiYoO3odZ1aOUdc1I,14394
 osbot_utils/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/version,sha256=mbIGfCYdUBYBX5IKj_GwRFeqsLHQ9YVfPa2A46aaruM,8
-osbot_utils-2.81.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-2.81.0.dist-info/METADATA,sha256=SxdVFb1ciwxBQdtsaYUtzLmGKHJAsJR7rSD9cRA4neM,7918
-osbot_utils-2.81.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-osbot_utils-2.81.0.dist-info/RECORD,,
+osbot_utils/version,sha256=qTe6foGALmPxx0zKmfZb_cxkz5FH_-oA-y4_stF2cqY,8
+osbot_utils-2.82.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-2.82.0.dist-info/METADATA,sha256=8Ugc0xBnuAYes9fAMJtnLyfCFxvsYqIzgloK_mEaN00,7918
+osbot_utils-2.82.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+osbot_utils-2.82.0.dist-info/RECORD,,