osbot-utils 2.80.0__tar.gz → 2.82.0__tar.gz

{osbot_utils-2.80.0 → osbot_utils-2.82.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.80.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.80.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.80.0 → osbot_utils-2.82.0}/README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.80.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.80.0 → osbot_utils-2.82.0}/osbot_utils/type_safe/Type_Safe__Base.py

@@ -1,5 +1,5 @@
 import types
-from typing                                                       import get_args, Union, Optional, Any, ForwardRef
+from typing                                                       import get_args, Union, Optional, Any, ForwardRef, Literal
 from osbot_utils.helpers.Obj_Id                                   import Obj_Id
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache import type_safe_cache
 
@@ -13,6 +13,13 @@ class Type_Safe__Base:
             return True
         origin = type_safe_cache.get_origin(expected_type)
         args   = get_args(expected_type)
+
+        if origin is Literal:                                       # Add Literal support
+            if item not in args:
+                allowed_values = ', '.join(repr(v) for v in args)
+                raise ValueError(f"Literal value must be one of {allowed_values}, got {repr(item)}")
+            return True
+
         if origin is None:
             if expected_type in EXACT_TYPE_MATCH:
                 if type(item) is expected_type:

{osbot_utils-2.80.0 → osbot_utils-2.82.0}/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
@@ -101,45 +131,44 @@ class Type_Safe__Method:
     def is_list_type(self, origin_type: Any) -> bool:                                 # Check if type is a List
         return origin_type is list or origin_type is List                             # Check against list types
 
-    def validate_list_type(self, param_name: str,                                     # Validate list type and contents
-                         param_value: Any, expected_type: Any):                        # List parameters
-        if not isinstance(param_value, list):                                         # Check if value is a list
-            raise ValueError(f"Parameter '{param_name}' expected a list but got {type(param_value)}")  # Raise error if not list
-
-        item_type = get_args(expected_type)[0]                                        # Get list item type
-        item_origin = get_origin(item_type)                                           # Get origin of item type
-
-        if item_origin is dict or item_origin is Dict:                                # Handle Dict[K, V] items
-            key_type, value_type = get_args(item_type)                                # Extract key and value types
-            for i, item in enumerate(param_value):                                    # Validate each dict in list
-                if not isinstance(item, dict):                                        # Check item is a dict
-                    raise ValueError(f"List item at index {i} expected dict but got {type(item)}")  # Raise error if not dict
-                if key_type is Any and value_type is Any:                            # Skip validation if both are Any
-                    continue                                                           # No type checking needed
-                for k, v in item.items():                                             # Validate dict contents
-                    if key_type is not Any and not isinstance(k, key_type):           # Check key type if not Any
-                        raise ValueError(f"Dict key '{k}' at index {i} expected type {key_type}, but got {type(k)}")  # Raise error for invalid key
-                    if value_type is not Any and not isinstance(v, value_type):       # Check value type if not Any
-                        raise ValueError(f"Dict value for key '{k}' at index {i} expected type {value_type}, but got {type(v)}")  # Raise error for invalid value
-        elif item_origin is collections.abc.Callable:                                 # Handle Callable[[...], ...] items
-            for i, item in enumerate(param_value):                                    # Validate each callable in list
-                if not callable(item):                                                # Check item is callable
-                    raise ValueError(f"List item at index {i} expected callable but got {type(item)}")  # Raise error if not callable
+    def validate_list_type(self, param_name: str,                                                                                   # Validate list type and contents
+                         param_value: Any, expected_type: Any):                                                                     # List parameters
+        if not isinstance(param_value, list):                                                                                       # Check if value is a list
+            raise ValueError(f"Parameter '{param_name}' expected a list but got {type(param_value)}")                               # Raise error if not list
+
+        item_type = get_args(expected_type)[0]                                                                                      # Get list item type
+        item_origin = get_origin(item_type)                                                                                         # Get origin of item type
+
+        if item_origin is dict or item_origin is Dict:                                                                              # Handle Dict[K, V] items
+            key_type, value_type = get_args(item_type)                                                                              # Extract key and value types
+            for i, item in enumerate(param_value):                                                                                  # Validate each dict in list
+                if not isinstance(item, dict):                                                                                      # Check item is a dict
+                    raise ValueError(f"List item at index {i} expected dict but got {type(item)}")                                  # Raise error if not dict
+                if key_type is Any and value_type is Any:                                                                           # Skip validation if both are Any
+                    continue                                                                                                        # No type checking needed
+                for k, v in item.items():                                                                                           # Validate dict contents
+                    if key_type is not Any and not isinstance(k, key_type):                                                         # Check key type if not Any
+                        raise ValueError(f"Dict key '{k}' at index {i} expected type {key_type}, but got {type(k)}")                # Raise error for invalid key
+                    if value_type is not Any and not isinstance(v, value_type):                                                     # Check value type if not Any
+                        raise ValueError(f"Dict value for key '{k}' at index {i} expected type {value_type}, but got {type(v)}")    # Raise error for invalid value
+        elif item_origin is collections.abc.Callable:                                                                               # Handle Callable[[...], ...] items
+            for i, item in enumerate(param_value):                                                                                  # Validate each callable in list
+                if not callable(item):                                                                                              # Check item is callable
+                    raise ValueError(f"List item at index {i} expected callable but got {type(item)}")                              # Raise error if not callable
                 # Note: Full signature validation would require is_callable_compatible method
-        elif item_origin is not None:                                                 # Handle other subscripted types
+        elif item_origin is not None:                                                                                               # Handle other subscripted types
             raise NotImplementedError(f"Validation for list items with subscripted type"
                                       f" '{item_type}' is not yet supported "
-                                      f"in parameter '{param_name}'.")                # todo: add support for checking for subscripted types
-        else:                                                                         # Handle non-subscripted types
-            for i, item in enumerate(param_value):                                    # Check each list item
-                if not isinstance(item, item_type):                                   # Validate item type
-                    raise ValueError(f"List item at index {i} expected type {item_type}, but got {type(item)}")  # Raise error for invalid item
+                                      f"in parameter '{param_name}'.")                                                              # todo: add support for checking for subscripted types
+        else:                                                                                                                       # Handle non-subscripted types
+            for i, item in enumerate(param_value):                                                                                  # Check each list item
+                if not isinstance(item, item_type):                                                                                 # Validate item type
+                    raise ValueError(f"List item at index {i} expected type {item_type}, but got {type(item)}")                     # Raise error for invalid item
 
-    def validate_type_parameter(self, param_name: str, param_value: Any, expected_type: Any):           # Validate a Type[T] parameter
+    def validate_type_parameter(self, param_name: str, param_value: Any, expected_type: Any):                                       # Validate a Type[T] parameter
         if not isinstance(param_value, type):
             raise ValueError(f"Parameter '{param_name}' expected a type class but got {type(param_value)}")
 
-
         type_args = get_args(expected_type)                                                         # Extract the T from Type[T]
         if type_args:
             required_base = type_args[0]                                                            # get direct type (this doesn't handle Forward refs)

{osbot_utils-2.80.0 → osbot_utils-2.82.0}/osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Validation.py

@@ -3,7 +3,7 @@ import inspect
 import types
 import typing
 from enum                                                                     import EnumMeta
-from typing                                                                   import Any, Annotated, Optional, get_args, get_origin, ForwardRef, Type, Dict, _GenericAlias
+from typing                                                                   import Any, Annotated, Optional, get_args, get_origin, ForwardRef, Type, Dict, _GenericAlias # noqa (_GenericAlias does exist)
 from osbot_utils.type_safe.Type_Safe__Primitive                               import Type_Safe__Primitive
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Annotations       import type_safe_annotations
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache             import type_safe_cache
@@ -50,12 +50,21 @@ class Type_Safe__Validation:
             return True
         if target_type is MagicMock:
             return True
-        # if class_full_name(source_type) == 'unittest.mock.MagicMock':
-        #     return True
-        # if class_full_name(target_type) == 'unittest.mock.MagicMock':
-        #     return True
         return False
 
+    def obj_is_type_literal_compatible(self, var_type) -> bool:     # Check if a Literal type contains only immutable values
+        from typing import Literal
+
+        origin = get_origin(var_type)
+        if origin is not Literal:
+            return False
+
+        literal_values = get_args(var_type)
+        for value in literal_values:
+            if value is not None and type(value) not in (bool, int, float, complex, str, bytes):
+                return False
+        return True
+
     def obj_is_type_union_compatible(self, var_type, compatible_types):
         from typing import Union
 
@@ -92,7 +101,7 @@ class Type_Safe__Validation:
         return None
 
     def check_if__value_is__special_generic_alias(self, value):
-        from typing import _SpecialGenericAlias                                     # todo see if there is a better way to do this since typing is showing as not having _SpecialGenericAlias (this is to handle case like List, Dict, etc...)
+        from typing import _SpecialGenericAlias                                     # noqa todo see if there is a better way to do this since typing is showing as not having _SpecialGenericAlias (this is to handle case like List, Dict, etc...)
         return value is not None and type(value) is not _SpecialGenericAlias
 
     def check_if__type_matches__union_type(self, annotation : Any,                                      # Union type annotation
@@ -163,6 +172,10 @@ class Type_Safe__Validation:
         if attr_type:
             origin_attr_type = get_origin(attr_type)                                    # to handle when type definition contains a generic
 
+            if origin_attr_type is typing.Literal:                                      # Add Literal support
+                literal_values = get_args(attr_type)
+                return value in literal_values
+
             if origin_attr_type is collections.abc.Callable:                            # Handle Callable types
                 return self.is_callable_compatible(value, attr_type)                    # ISSUE: THIS IS NEVER CALLED
 
@@ -286,12 +299,27 @@ class Type_Safe__Validation:
 
     # todo: see if need to add cache support to this method     (it looks like this method is not called very often)
     def validate_type_immutability(self, var_name: str, var_type: Any) -> None:                         # Validates that type is immutable or in supported format
-        if var_type not in IMMUTABLE_TYPES and var_name.startswith('__') is False:                      # if var_type is not one of the IMMUTABLE_TYPES or is an __ internal
-            if self.obj_is_type_union_compatible(var_type, IMMUTABLE_TYPES) is False:                        # if var_type is not something like Optional[Union[int, str]]
-                if var_type not in IMMUTABLE_TYPES or type(var_type) not in IMMUTABLE_TYPES:
-                    if not isinstance(var_type, EnumMeta):
-                        if not (isinstance(var_type, type) and issubclass(var_type, (int,str, float))):
-                            type_safe_raise_exception.immutable_type_error(var_name, var_type)
+        if var_type in IMMUTABLE_TYPES or var_name.startswith('__'):                                      # if var_type is not one of the IMMUTABLE_TYPES or is an __ internal
+            return
+        if self.obj_is_type_literal_compatible(var_type):
+            return
+        if self.obj_is_type_union_compatible(var_type, IMMUTABLE_TYPES) :                                   # if var_type is not something like Optional[Union[int, str]]
+            return
+        if var_type in IMMUTABLE_TYPES:
+            return
+        if  isinstance(var_type, EnumMeta):
+            return
+        if isinstance(var_type, type) and issubclass(var_type, (int,str, float)):
+            return
+        type_safe_raise_exception.immutable_type_error(var_name, var_type)
+
+    # def validate_type_immutability(self, var_name: str, var_type: Any) -> None:                         # Validates that type is immutable or in supported format
+    #     if var_type not in IMMUTABLE_TYPES and var_name.startswith('__') is False:                      # if var_type is not one of the IMMUTABLE_TYPES or is an __ internal
+    #         if self.obj_is_type_union_compatible(var_type, IMMUTABLE_TYPES) is False:                        # if var_type is not something like Optional[Union[int, str]]
+    #             if var_type not in IMMUTABLE_TYPES or type(var_type) not in IMMUTABLE_TYPES:
+    #                 if not isinstance(var_type, EnumMeta):
+    #                     if not (isinstance(var_type, type) and issubclass(var_type, (int,str, float))):
+    #                         type_safe_raise_exception.immutable_type_error(var_name, var_type)
 
     def validate_variable_type(self, var_name, var_type, var_value):                                # Validate type compatibility
         if type(var_type) is type and not isinstance(var_value, var_type):

{osbot_utils-2.80.0 → osbot_utils-2.82.0}/osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Set_Attr.py

@@ -1,10 +1,10 @@
-from typing                                                  import get_origin, Annotated, get_args
-from osbot_utils.type_safe.Type_Safe__Primitive              import Type_Safe__Primitive
-from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List import Type_Safe__List
-from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache import type_safe_cache
-from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Convert import type_safe_convert
-from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Validation import type_safe_validation
-from osbot_utils.type_safe.validators.Type_Safe__Validator   import Type_Safe__Validator
+from typing                                                             import get_origin, Annotated, get_args, Literal, Union
+from osbot_utils.type_safe.Type_Safe__Primitive                         import Type_Safe__Primitive
+from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List   import Type_Safe__List
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache       import type_safe_cache
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Convert     import type_safe_convert
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Validation  import type_safe_validation
+from osbot_utils.type_safe.validators.Type_Safe__Validator              import Type_Safe__Validator
 
 class Type_Safe__Step__Set_Attr:
 
@@ -20,6 +20,8 @@ class Type_Safe__Step__Set_Attr:
         else:
             value = self.resolve_value__from_origin(value)
 
+        self.validate_literal_value(annotations, name, value)                            # Check Literal value constraints before generic type checking
+
         type_safe_validation.validate_type_compatibility(_self, annotations, name, value)
         return value
 
@@ -111,5 +113,31 @@ class Type_Safe__Step__Set_Attr:
 
         _super.__setattr__(name, value)
 
+    def validate_literal_value(self, annotations, name, value):     # Check if a value is valid for a Literal type annotation
+
+        annotation = annotations.get(name)
+        if not annotation:
+            return
+
+        origin = get_origin(annotation)
+
+        if origin is Union:                                                     # Handle Optional[Literal[...]] by unwrapping the Optional
+            args = get_args(annotation)
+            if type(None) in args:                                              # Check if it's Optional (Union with None)
+                for arg in args:                                                # Find the non-None type
+                    if arg is not type(None) and get_origin(arg) is Literal:
+                        allowed_values = get_args(arg)                          # Found Literal inside Optional
+                        if value is not None and value not in allowed_values:
+                            allowed_str = ', '.join(repr(v) for v in allowed_values)
+                            raise ValueError(f"Invalid value for '{name}': must be one of [{allowed_str}], got {repr(value)}")
+                        return
+
+
+        elif origin is Literal:                                                 # Handle direct Literal[...]
+            allowed_values = get_args(annotation)
+            if value not in allowed_values:
+                allowed_str = ', '.join(repr(v) for v in allowed_values)
+                raise ValueError(f"Invalid value for '{name}': must be one of [{allowed_str}], got {repr(value)}")
+
 
 type_safe_step_set_attr = Type_Safe__Step__Set_Attr()

osbot_utils-2.82.0/osbot_utils/version

@@ -0,0 +1 @@
+v2.82.0

{osbot_utils-2.80.0 → osbot_utils-2.82.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "osbot_utils"
-version     = "v2.80.0"
+version     = "v2.82.0"
 description = "OWASP Security Bot - Utils"
 authors     = ["Dinis Cruz <dinis.cruz@owasp.org>"]
 license     = "MIT"

osbot_utils-2.80.0/osbot_utils/version

@@ -1 +0,0 @@
-v2.80.0