osbot-utils 2.87.0__tar.gz → 2.89.0__tar.gz

{osbot_utils-2.87.0 → osbot_utils-2.89.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.87.0
+Version: 2.89.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.87.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.89.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.87.0 → osbot_utils-2.89.0}/README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.87.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.89.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.87.0 → osbot_utils-2.89.0}/osbot_utils/helpers/duration/decorators/capture_duration.py

@@ -1,5 +1,4 @@
 import time
-
 from osbot_utils.type_safe.Type_Safe import Type_Safe
 
 

osbot_utils-2.89.0/osbot_utils/helpers/html/schemas/Schema__Html_Node__Data__Type.py

@@ -0,0 +1,4 @@
+from enum import Enum
+
+class Schema__Html_Node__Data__Type(str, Enum):
+    TEXT : str = 'text'

{osbot_utils-2.87.0 → osbot_utils-2.89.0}/osbot_utils/helpers/llms/builders/LLM_Request__Builder.py

@@ -1,14 +1,14 @@
-from typing                                                                 import Dict, Any, Type
-from osbot_utils.helpers.llms.actions.Type_Safe__Schema_For__LLMs           import Type_Safe__Schema_For__LLMs
-from osbot_utils.helpers.llms.schemas.Safe_Str__LLM__Model_Name             import Safe_Str__LLM__Model_Name
-from osbot_utils.helpers.llms.schemas.Schema__LLM_Request                   import Schema__LLM_Request
-from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Data             import Schema__LLM_Request__Data
-from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Function_Call    import Schema__LLM_Request__Function_Call
-from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Message__Content import Schema__LLM_Request__Message__Content
-from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Message__Role    import Schema__LLM_Request__Message__Role
-from osbot_utils.type_safe.Type_Safe                                        import Type_Safe
-from osbot_utils.type_safe.primitives.safe_str.text.Safe_Str__Text          import Safe_Str__Text
-from osbot_utils.type_safe.type_safe_core.decorators.type_safe              import type_safe
+from typing                                                                  import Dict, Any, Type
+from osbot_utils.helpers.llms.actions.Type_Safe__Schema_For__LLMs            import Type_Safe__Schema_For__LLMs
+from osbot_utils.type_safe.primitives.safe_str.llm.Safe_Str__LLM__Model_Name import Safe_Str__LLM__Model_Name
+from osbot_utils.helpers.llms.schemas.Schema__LLM_Request                    import Schema__LLM_Request
+from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Data              import Schema__LLM_Request__Data
+from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Function_Call     import Schema__LLM_Request__Function_Call
+from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Message__Content  import Schema__LLM_Request__Message__Content
+from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Message__Role     import Schema__LLM_Request__Message__Role
+from osbot_utils.type_safe.Type_Safe                                         import Type_Safe
+from osbot_utils.type_safe.primitives.safe_str.text.Safe_Str__Text           import Safe_Str__Text
+from osbot_utils.type_safe.type_safe_core.decorators.type_safe               import type_safe
 
 
 class LLM_Request__Builder(Type_Safe):

{osbot_utils-2.87.0 → osbot_utils-2.89.0}/osbot_utils/helpers/llms/schemas/Schema__LLM_Request__Data.py

@@ -1,9 +1,9 @@
-from typing                                                                 import List, Optional
-from osbot_utils.helpers.llms.schemas.Safe_Str__LLM__Model_Name             import Safe_Str__LLM__Model_Name
-from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Function_Call    import Schema__LLM_Request__Function_Call
-from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Message__Content import Schema__LLM_Request__Message__Content
-from osbot_utils.type_safe.Type_Safe                                        import Type_Safe
-from osbot_utils.type_safe.primitives.safe_str.text.Safe_Str__Text         import Safe_Str__Text
+from typing                                                                     import List, Optional
+from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Function_Call        import Schema__LLM_Request__Function_Call
+from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Message__Content     import Schema__LLM_Request__Message__Content
+from osbot_utils.type_safe.Type_Safe                                            import Type_Safe
+from osbot_utils.type_safe.primitives.safe_str.llm.Safe_Str__LLM__Model_Name    import Safe_Str__LLM__Model_Name
+from osbot_utils.type_safe.primitives.safe_str.text.Safe_Str__Text              import Safe_Str__Text
 
 
 class Schema__LLM_Request__Data(Type_Safe):                                         # Schema for LLM API request data

{osbot_utils-2.87.0 → osbot_utils-2.89.0}/osbot_utils/type_safe/Type_Safe.py

@@ -88,7 +88,7 @@ class Type_Safe:
             if value is not None:
                 if hasattr(self,'__annotations__'):  # can only do type safety checks if the class does not have annotations
                     if type_safe_validation.check_if__type_matches__obj_annotation__for_attr(self, key, value) is False:
-                        raise ValueError(f"Invalid type for attribute '{key}'. Expected '{self.__annotations__.get(key)}' but got '{type(value)}'")
+                        raise ValueError(f"On {self.__class__.__name__} invalid type for attribute '{key}'. Expected '{self.__annotations__.get(key)}' but got '{type(value)}'")
                 setattr(self, key, value)
         return self
 

{osbot_utils-2.87.0 → osbot_utils-2.89.0}/osbot_utils/type_safe/primitives/safe_str/Safe_Str.py

@@ -8,16 +8,16 @@ TYPE_SAFE__STR__MAX_LENGTH      = 512
 
 
 class Safe_Str(Type_Safe__Primitive, str):
+    allow_all_replacement_char: bool                       = True
+    allow_empty               : bool                       = True                # note: making this False does cause some side effects on .json() on cases like auto serialization in environments like FastAPI (like it requires more explict value setting), so all have now been converted into a value of True
+    exact_length              : bool                       = False               # If True, require exact length match, not just max length
     max_length                : int                        = TYPE_SAFE__STR__MAX_LENGTH
     regex                     : re.Pattern                 = TYPE_SAFE__STR__REGEX__SAFE_STR
     regex_mode                : Enum__Safe_Str__Regex_Mode = Enum__Safe_Str__Regex_Mode.REPLACE
     replacement_char          : str                        = '_'
-    allow_empty               : bool                       = True                # note: making this False does cause some side effects on .json() on cases like auto serialization in environments like FastAPI (like it requires more explict value setting), so all have now been converted into a value of True
-    trim_whitespace           : bool                       = False
-    allow_all_replacement_char: bool                       = True
     strict_validation         : bool                       = False               # If True, don't replace invalid chars, raise an error instead
-    exact_length              : bool                       = False               # If True, require exact length match, not just max length
-
+    to_lower_case             : bool                       = False               # If True, convert string to lowercase
+    trim_whitespace           : bool                       = False
 
     def __new__(cls, value: Optional[str] = None) -> 'Safe_Str':
 
@@ -46,6 +46,8 @@ class Safe_Str(Type_Safe__Primitive, str):
 
         sanitized_value = cls.validate_and_sanitize(value)
 
+        if cls.to_lower_case:
+            sanitized_value = sanitized_value.lower()
 
         return str.__new__(cls, sanitized_value)
 

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Enum__LLM__Role.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class Enum__LLM__Role(str, Enum): # Extended roles for specific providers
+    SYSTEM    = "system"
+    USER      = "user"
+    ASSISTANT = "assistant"
+    TOOL      = "tool"
+
+    def __str__(self):
+        return self.value  # Override to return the value

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Safe_Str__LLM__Description.py

@@ -0,0 +1,14 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+class Safe_Str__LLM__Description(Safe_Str):                                            # LLM model or feature description
+    max_length = 4096
+    regex      = re.compile(r'[^a-zA-Z0-9_ ()\[\]\-+=:;,.?*/\\×\n`&"\'#%<>{}$@|!\s~]')  # Allows common description chars
+
+    # Supports rich descriptions with:
+    # - Basic punctuation and formatting
+    # - Mathematical symbols (×, +, -)
+    # - Common special characters for technical descriptions
+    # - Newlines for multi-line descriptions
+    # - Brackets for annotations [like this]
+    # - Quotes for "emphasis" or 'terms'

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Safe_Str__LLM__Message__Assistant.py

@@ -0,0 +1,7 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+
+class Safe_Str__LLM__Message__Assistant(Safe_Str):              # For assistant/AI responses
+    max_length  = 32768                                         # Full context window for responses
+    regex       = re.compile(r'[\x00-\x08\x0B\x0C\x0E-\x1F]')   # Permissive - only control chars

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Safe_Str__LLM__Message__System.py

@@ -0,0 +1,7 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+
+class Safe_Str__LLM__Message__System(Safe_Str):  # For system prompts
+    max_length  = 4096                                         # Shorter than full prompts
+    regex = re.compile(r'[\x00-\x08\x0B\x0C\x0E-\x1F]')        # Remove control chars EXCEPT tab (\x09), newline (\x0A), and carriage return (\x0D)

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Safe_Str__LLM__Message__Tool.py

@@ -0,0 +1,7 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+
+class Safe_Str__LLM__Message__Tool(Safe_Str):                   # For tool/function responses
+    max_length  = 16384                                         # Tool responses often shorter
+    regex       = re.compile(r'[\x00-\x08\x0B\x0C\x0E-\x1F]')   # Permissive for JSON/structured data

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Safe_Str__LLM__Message__User.py

@@ -0,0 +1,7 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+
+class Safe_Str__LLM__Message__User(Safe_Str):                  # For user messages
+    max_length  = 32768                                        # Full context window for user input
+    regex       = re.compile(r'[\x00-\x08\x0B\x0C\x0E-\x1F]')  # Permissive - only control chars

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Safe_Str__LLM__Modality.py

@@ -0,0 +1,14 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+class Safe_Str__LLM__Modality(Safe_Str):                                        # LLM model modality descriptor
+    max_length = 128
+    regex      = re.compile(r'[^a-zA-Z0-9+\->\s]')                             # Allows: alphanumeric, +, -, >, space
+
+    # Supports modality descriptions:
+    # - "text"
+    # - "text->image"
+    # - "image+text->text"
+    # - "multimodal"
+    # - "text + vision"
+    # - "audio->text"

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Safe_Str__LLM__Model_ID.py

@@ -0,0 +1,14 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+class Safe_Str__LLM__Model_ID(Safe_Str):                                        # Generic LLM model identifier
+    max_length = 256
+    regex      = re.compile(r'[^a-zA-Z0-9/\-.:_@]')                             # Allows: alphanumeric, /, -, ., :, _, @
+
+
+    # Supports various model ID formats:
+    # - OpenRouter: "openai/gpt-4", "anthropic/claude-3-opus"
+    # - OpenAI: "gpt-4", "gpt-3.5-turbo"
+    # - Anthropic: "claude-3-opus-20240229", "claude-3-sonnet@20240229"
+    # - Cohere: "command-r-plus"
+    # - Google: "models/gemini-pro"

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Safe_Str__LLM__Model_Name.py

@@ -0,0 +1,13 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+class Safe_Str__LLM__Model_Name(Safe_Str):                                      # Human-readable LLM model name
+    max_length = 256
+    regex = re.compile(r'[^a-zA-Z0-9: .\-()+,]')                               # Allows: alphanumeric, :, space, ., -, (, ), +, &, ,
+
+    # Supports various display names:
+    # - "GPT-4 Turbo"
+    # - "Claude 3 Opus (Latest)"
+    # - "Llama 3.1: Instruct (70B)"
+    # - "Command R+"
+    # - "Gemini Pro 1.5"

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Safe_Str__LLM__Model_Slug.py

@@ -0,0 +1,12 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+class Safe_Str__LLM__Model_Slug(Safe_Str):                                      # URL-safe LLM model slug
+    max_length = 256
+    regex      = re.compile(r'[^a-zA-Z0-9/\-._]')                              # Allows: alphanumeric, /, -, ., _
+
+    # URL-safe slugs for routing/APIs:
+    # - "gpt-4-turbo"
+    # - "claude-3-opus"
+    # - "llama-3.1-70b"
+    # - "command_r_plus"

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Safe_Str__LLM__Prompt.py

@@ -0,0 +1,7 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+
+class Safe_Str__LLM__Prompt(Safe_Str):                       # Or Safe_Str__LLM__Message
+    max_length = 32768                                       # Common context window size
+    regex = re.compile(r'[\x00\x01-\x08\x0B\x0C\x0E-\x1F]')  # Remove control chars only

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/llm/Safe_Str__LLM__Tokenizer.py

@@ -0,0 +1,13 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+class Safe_Str__LLM__Tokenizer(Safe_Str):                                       # LLM tokenizer type identifier
+    max_length = 64
+    regex      = re.compile(r'[^a-zA-Z0-9\-_\s]')                              # Allows: alphanumeric, -, _, space
+
+    # Supports tokenizer names:
+    # - "cl100k_base"
+    # - "tiktoken"
+    # - "GPT-4 Tokenizer"
+    # - "sentencepiece"
+    # - "BPE"

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/text/Safe_Str__Code__Snippet.py

@@ -0,0 +1,9 @@
+import re
+
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+
+class Safe_Str__Code__Snippet(Safe_Str):     # Allows various characters needed for code snippets.
+    regex = re.compile(r'[^a-zA-Z0-9_\-.\s(),;:=+\[\]{}\'"]<>')
+    max_length = 1024
+    trim_whitespace = False  # Preserve leading whitespace for code indentation

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/web/Safe_Str__API__Parameter.py

@@ -0,0 +1,13 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+class Safe_Str__API__Parameter(Safe_Str):                                       # Generic API parameter name
+    max_length = 64
+    regex      = re.compile(r'[^a-zA-Z0-9_]')                                  # Allows: alphanumeric, _
+
+    # Standard API parameter names:
+    # - "max_tokens"
+    # - "temperature"
+    # - "top_p"
+    # - "stream"
+    # - "response_format"

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/web/Safe_Str__Email.py

@@ -0,0 +1,12 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+class Safe_Str__Email(Safe_Str):    # Special class for emails with simple custom validation.
+    regex = re.compile(r'[^a-zA-Z0-9_\-.@]')
+    max_length = 256
+
+    def __new__(cls, value=None):
+        result = super().__new__(cls, value)
+        if '@' not in result:                                                               # Additional validation for email format
+            raise ValueError(f"in {cls.__name__}, email must contain an @ symbol")
+        return result

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/web/Safe_Str__Password.py

@@ -0,0 +1,14 @@
+import re
+
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+
+class Safe_Str__Password(Safe_Str): # Password with minimum requirements.
+    regex = re.compile(r'[^a-zA-Z0-9_\-.\s!@#$%^&*()]')
+    min_length = 8  # Custom attribute
+
+    def __new__(cls, value=None):
+        result = super().__new__(cls, value)
+        if len(result) < cls.min_length:
+            raise ValueError(f"Password must be at least {cls.min_length} characters long")
+        return result

osbot_utils-2.89.0/osbot_utils/type_safe/primitives/safe_str/web/Safe_Str__Username.py

@@ -0,0 +1,8 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+
+class Safe_Str__Username(Safe_Str):
+    """Allows only alphanumerics and underscores, with a 32 character limit."""
+    regex = re.compile(r'[^a-zA-Z0-9_]')
+    max_length = 32

osbot_utils-2.89.0/osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Raise_Exception.py

@@ -0,0 +1,18 @@
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
+
+
+class Type_Safe__Raise_Exception:
+
+    def type_mismatch_error__on_instance(self, _self, var_name: str, expected_type: type, actual_type: type) -> None:                               # Raises formatted error for type validation failures
+        exception_message = f"On {_self.__class__.__name__}, invalid type for attribute '{var_name}'. Expected '{expected_type}' but got '{actual_type}'"
+        raise ValueError(exception_message) from None
+
+    def type_mismatch_error__on_type(self, cls, var_name: str, expected_type: type, actual_type: type) -> None:                               # Raises formatted error for type validation failures
+        exception_message = f"On {cls.__name__}, invalid type for attribute '{var_name}'. Expected '{expected_type}' but got '{actual_type}'"
+        raise ValueError(exception_message) from None
+
+    def immutable_type_error(self, var_name, var_type):
+        exception_message = f"variable '{var_name}' is defined as type '{var_type}' which is not supported by Type_Safe, with only the following immutable types being supported: '{IMMUTABLE_TYPES}' and the following subclasses (int, float, str)"
+        raise ValueError(exception_message) from None
+
+type_safe_raise_exception = Type_Safe__Raise_Exception()

{osbot_utils-2.87.0 → osbot_utils-2.89.0}/osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Validation.py

@@ -270,11 +270,11 @@ class Type_Safe__Validation:
     def validate_if_value_has_been_set(self, _self, annotations, name, value):
         if hasattr(_self, name) and annotations.get(name) :     # don't allow previously set variables to be set to None
             if getattr(_self, name) is not None:                         # unless it is already set to None
-                raise ValueError(f"Can't set None, to a variable that is already set. Invalid type for attribute '{name}'. Expected '{_self.__annotations__.get(name)}' but got '{type(value)}'")
+                raise ValueError(f"On {_self.__class__.__name__}, can't be set to None, to a variable that is already set. Invalid type for attribute '{name}'. Expected '{_self.__annotations__.get(name)}' but got '{type(value)}'")
 
-    def validate_if__types_are_compatible_for_assigment(self, name, current_type, expected_type):
+    def validate_if__types_are_compatible_for_assigment(self, _self, name, current_type, expected_type):
         if not type_safe_validation.are_types_compatible_for_assigment(current_type, expected_type):
-            type_safe_raise_exception.type_mismatch_error(name, expected_type, current_type)
+            type_safe_raise_exception.type_mismatch_error__on_instance(_self, name, expected_type, current_type)
 
     def validate_type_compatibility(self, target      : Any             ,             # Target object to validate
                                           annotations : Dict[str, Any]  ,             # Type annotations
@@ -295,7 +295,7 @@ class Type_Safe__Validation:
                 actual_type = value
             else:
                 actual_type = type(value)
-            raise ValueError(f"Invalid type for attribute '{name}'. Expected '{expected_type}' but got '{actual_type}'") from None
+            raise ValueError(f"On {target.__class__.__name__}, invalid type for attribute '{name}'. Expected '{expected_type}' but got '{actual_type}'") from None
 
     # 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
@@ -321,8 +321,8 @@ class Type_Safe__Validation:
     #                     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
+    def validate_variable_type(self, base_cls, var_name, var_type, var_value):                                # Validate type compatibility
         if type(var_type) is type and not isinstance(var_value, var_type):
-            type_safe_raise_exception.type_mismatch_error(var_name, var_type, type(var_value))
+            type_safe_raise_exception.type_mismatch_error__on_type(base_cls, var_name, var_type, type(var_value))
 
 type_safe_validation = Type_Safe__Validation()

{osbot_utils-2.87.0 → osbot_utils-2.89.0}/osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Class_Kwargs.py

@@ -96,7 +96,7 @@ class Type_Safe__Step__Class_Kwargs:
                 # If conversion fails, let the original validation handle it
                 pass
 
-        type_safe_validation.validate_variable_type(var_name, var_type, var_value)
+        type_safe_validation.validate_variable_type(base_cls, var_name, var_type, var_value)
         type_safe_validation.validate_type_immutability(var_name, var_type)
 
     def process_annotation(self, cls      : Type           ,                            # Process single annotation

{osbot_utils-2.87.0 → osbot_utils-2.89.0}/osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Init.py

@@ -33,13 +33,16 @@ class Type_Safe__Step__Init:
                 raise ValueError(f"{__self.__class__.__name__} has no attribute '{key}' and cannot be assigned the value '{value}'. "
                                  f"Use {__self.__class__.__name__}.__default_kwargs__() see what attributes are available") from None
 
-    def convert_value_to_type_safe_objects(self, __self, key, value):                                # todo: see if we should use _self here (like in Type_Safe__Step__From_Json, or vice versa)
+    def convert_value_to_type_safe_objects(self, __self, key, value):
         annotation = type_safe_annotations.obj_attribute_annotation(__self, key)
         if annotation:
             if isinstance(annotation, EnumMeta) and type(value) is str:
-                if value not in annotation.__members__:
+                if value in annotation.__members__:                                                             # First check if it's a valid name (e.g., 'SYSTEM')
+                    value = annotation[value]
+                elif hasattr(annotation, '_value2member_map_') and value in annotation._value2member_map_:      # Then check if it's a valid value (e.g., 'system')
+                    value = annotation._value2member_map_[value]
+                else:
                     raise ValueError(f"Invalid value '{value}' for enum {annotation.__name__}")
-                value = annotation[value]
             else:
 
                 origin = type_safe_annotations.get_origin(annotation)

{osbot_utils-2.87.0 → osbot_utils-2.89.0}/osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Set_Attr.py

@@ -22,7 +22,7 @@ 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
+        self.validate_literal_value(_self, annotations, name, value)                            # Check Literal value constraints before generic type checking
 
         type_safe_validation.validate_type_compatibility(_self, annotations, name, value)
         return value
@@ -106,7 +106,7 @@ class Type_Safe__Step__Set_Attr:
         if name in immutable_vars:
             expected_type = immutable_vars[name]
             current_type  = type if value is type else type(value)
-            type_safe_validation.validate_if__types_are_compatible_for_assigment(name, current_type, expected_type)
+            type_safe_validation.validate_if__types_are_compatible_for_assigment(_self, name, current_type, expected_type)
             _super.__setattr__(name, value)
             return True
         return False
@@ -129,7 +129,7 @@ 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
+    def validate_literal_value(self, _self, annotations, name, value):     # Check if a value is valid for a Literal type annotation
 
         annotation = annotations.get(name)
         if not annotation:
@@ -145,7 +145,7 @@ class Type_Safe__Step__Set_Attr:
                         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)}")
+                            raise ValueError(f"On {_self.__class__.__name__}, invalid value for '{name}': must be one of [{allowed_str}], got {repr(value)}")
                         return
 
 
@@ -153,7 +153,7 @@ class Type_Safe__Step__Set_Attr:
             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)}")
+                raise ValueError(f"On {_self.__class__.__name__}, 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.87.0 → osbot_utils-2.89.0}/osbot_utils/utils/Objects.py

@@ -1,5 +1,4 @@
-from types import SimpleNamespace
-
+from types                  import SimpleNamespace
 from osbot_utils.testing.__ import __
 
 def base_classes(cls):
@@ -96,10 +95,13 @@ def str_to_obj(target):
     return dict_to_obj(json.loads(target))
 
 def enum_from_value(enum_type, value):
-    try:
-        return enum_type[value]         # Attempt to convert the value to an Enum member by name
-    except KeyError:
-        raise ValueError(f"Value '{value}' is not a valid member of {enum_type.__name__}.")     # Handle the case where the value does not match any Enum member
+    if value in enum_type.__members__:                                                              # Try to get by name (e.g., 'SYSTEM')
+        return enum_type[value]
+
+    if hasattr(enum_type, '_value2member_map_') and value in enum_type._value2member_map_:          # Try to get by value (e.g., 'system') using the reverse mapping
+        return enum_type._value2member_map_[value]
+
+    raise ValueError(f"Value '{value}' is not a valid member of {enum_type.__name__}.")             # If neither worked, raise an error
 
 
 def get_field(target, field, default=None):
@@ -276,13 +278,18 @@ def serialize_to_dict(obj):
         return obj.json()                                                                           #   use the provided .json() method, which handles the type conversions more specifically to those types (dict, list, set and tuple)
     elif hasattr(obj, '__primitive_base__') and isinstance(obj, (str, int, float)):
         return obj.__primitive_base__(obj)
+    elif isinstance(obj, Enum):
+        if isinstance(obj.value, (str, int, float, bool, type(None))):                          # Check if the enum value is directly serializable
+            return obj.value
+        elif isinstance(obj.value, (list, tuple, dict, set)):                                        # Recursively serialize complex values
+            return serialize_to_dict(obj.value)
+        else:
+            return obj.name                                                                     # Fallback to name for non-serializable values
     elif isinstance(obj, (str, int, float, bool, bytes, Decimal)) or obj is None:                # todo: add support for objects like datetime
         return obj
-    elif isinstance(obj, Enum):
-        return obj.name
     elif isinstance(obj, type):
         return f"{obj.__module__}.{obj.__name__}"                                   # save the full type name
-    elif isinstance(obj, (list, tuple, List)):  # Added tuple here
+    elif isinstance(obj, (list, tuple, List)):                                     # Added tuple here
         return [serialize_to_dict(item) for item in obj]
     elif isinstance(obj, set):
         return [serialize_to_dict(item) for item in obj]
@@ -296,6 +303,12 @@ def serialize_to_dict(obj):
             serialized_dict[serialized_key] = serialize_to_dict(value)         # Recursively serialize the value
         return serialized_dict
         #return {key: serialize_to_dict(value) for key, value in obj.items()}
+    elif callable(obj) and not isinstance(obj, type):                                                         # For functions/lambdas, return a string representation
+        if hasattr(obj, '__name__'):
+            return obj.__name__
+        if hasattr(obj, '__class__'):
+            return obj.__class__.__name__
+        return str(obj)
     elif hasattr(obj, "__dict__"):
         data = {}                                                                   # todo: look at a more advanced version which saved the type of the object, for example with {'__type__': type(obj).__name__}
         for key, value in obj.__dict__.items():

osbot_utils-2.89.0/osbot_utils/version

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

{osbot_utils-2.87.0 → osbot_utils-2.89.0}/pyproject.toml

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

osbot_utils-2.87.0/osbot_utils/helpers/html/schemas/Schema__Html_Node__Data__Type.py

@@ -1,4 +0,0 @@
-from enum import Enum
-
-class Schema__Html_Node__Data__Type(Enum):
-    TEXT : str = 'text'

osbot_utils-2.87.0/osbot_utils/helpers/llms/schemas/Safe_Str__LLM__Model_Name.py

@@ -1,10 +0,0 @@
-import re
-
-from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
-
-TYPE_SAFE_STR__LLM__MODEL_NAME__MAX_LENGTH = 256
-TYPE_SAFE_STR__LLM__MODEL_NAME__REGEX      =  r'[^a-zA-Z0-9/_\-.:]'
-
-class Safe_Str__LLM__Model_Name(Safe_Str):
-    regex      = re.compile(TYPE_SAFE_STR__LLM__MODEL_NAME__REGEX)
-    max_length = TYPE_SAFE_STR__LLM__MODEL_NAME__MAX_LENGTH

osbot_utils-2.87.0/osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Raise_Exception.py

@@ -1,14 +0,0 @@
-from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
-
-
-class Type_Safe__Raise_Exception:
-
-    def type_mismatch_error(self, var_name: str, expected_type: type, actual_type: type) -> None:                               # Raises formatted error for type validation failures
-        exception_message = f"Invalid type for attribute '{var_name}'. Expected '{expected_type}' but got '{actual_type}'"
-        raise ValueError(exception_message) from None
-
-    def immutable_type_error(self, var_name, var_type):
-        exception_message = f"variable '{var_name}' is defined as type '{var_type}' which is not supported by Type_Safe, with only the following immutable types being supported: '{IMMUTABLE_TYPES}' and the following subclasses (int, float, str)"
-        raise ValueError(exception_message) from None
-
-type_safe_raise_exception = Type_Safe__Raise_Exception()

osbot_utils-2.87.0/osbot_utils/version

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