osbot-utils 2.84.0__tar.gz → 2.86.0__tar.gz

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/PKG-INFO

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

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.84.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.86.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.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/Type_Safe__Primitive.py

@@ -67,4 +67,9 @@ class Type_Safe__Primitive:
         if self.__primitive_base__ is str:
             return f"{type(self).__name__}('{value_str}')"
         else:
-            return f"{type(self).__name__}({value_str})"
+            return f"{type(self).__name__}({value_str})"
+
+    def __to_primitive__(self):                                     # Convert this Type_Safe__Primitive instance to its base primitive type.
+        if self.__primitive_base__:
+            return self.__primitive_base__(self)
+        return str(self)                                            # fallback

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/Safe_Str.py

@@ -12,7 +12,7 @@ class Safe_Str(Type_Safe__Primitive, str):
     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
+    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
@@ -34,12 +34,12 @@ class Safe_Str(Type_Safe__Primitive, str):
             value = value.strip()
 
         if not cls.allow_empty and (value is None or value == ""):                                                      # Check for empty string if not allowed
-            raise ValueError("Value cannot be empty when allow_empty is False")
+            raise ValueError(f"in {cls.__name__}, value cannot be empty when allow_empty is False")
 
-        if cls.exact_length and len(value) != cls.max_length:
-            raise ValueError(f"Value must be exactly {cls.max_length} characters long (was {len(value)})")
+        if cls.exact_length and len(value) and len(value) != cls.max_length:
+            raise ValueError(f"in {cls.__name__}, value must be exactly {cls.max_length} characters long (was {len(value)})")
         elif not cls.exact_length and len(value) > cls.max_length:                                                      # Check max length
-            raise ValueError(f"Value exceeds maximum length of {cls.max_length} characters (was {len(value)})")
+            raise ValueError(f"in {cls.__name__}, value exceeds maximum length of {cls.max_length} characters (was {len(value)})")
 
         if cls.allow_empty and value =='':
             return str.__new__(cls, '')
@@ -54,22 +54,22 @@ class Safe_Str(Type_Safe__Primitive, str):
         if cls.strict_validation:
             if cls.regex_mode == Enum__Safe_Str__Regex_Mode.MATCH:               # For 'match' mode, regex defines the valid pattern (like version numbers)
                 if not cls.regex.match(value):
-                    raise ValueError(f"Value does not match required pattern: {cls.regex.pattern}")
+                    raise ValueError(f"in {cls.__name__}, value does not match required pattern: {cls.regex.pattern}")
                 return value
             elif cls.regex_mode == Enum__Safe_Str__Regex_Mode.REPLACE:           # For 'replace' mode, regex defines invalid characters to replace
                 if cls.regex.search(value) is not None:
-                    raise ValueError(f"Value contains invalid characters (must not match pattern: {cls.regex.pattern})")
+                    raise ValueError(f"in {cls.__name__}, value contains invalid characters (must not match pattern: {cls.regex.pattern})")
                 return value
             else:
                 raise ValueError(f"in {cls.__name__}, regex_mode value cannot be None when strict_validation is True")
         else:
             if cls.regex_mode == Enum__Safe_Str__Regex_Mode.MATCH:               # Cannot do replacement when regex defines valid pattern
-                raise ValueError(f"Cannot use regex_mode='match' without strict_validation=True")
+                raise ValueError(f"in {cls.__name__}, cannot use regex_mode='match' without strict_validation=True")
             else:                                                                # assume the default Enum__Safe_Str__Regex_Mode.MATCH
                 sanitized_value =  cls.regex.sub(cls.replacement_char, value)
 
                 if not cls.allow_all_replacement_char and set(sanitized_value) == {
                     cls.replacement_char} and sanitized_value:
-                    raise ValueError(f"Sanitized value consists entirely of '{cls.replacement_char}' characters")
+                    raise ValueError(f"in {cls.__name__}, sanitized value consists entirely of '{cls.replacement_char}' characters")
 
                 return sanitized_value

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/cryptography/hashes/Safe_Str__Hash.py

@@ -10,10 +10,10 @@ TYPE_SAFE_STR__HASH__REGEX = re.compile(r'[^a-fA-F0-9]')                # Only a
 class Safe_Str__Hash(Safe_Str):
     regex                     = TYPE_SAFE_STR__HASH__REGEX
     max_length                = SIZE__VALUE_HASH
-    allow_empty               = False                                   # Don't allow empty hash values
-    trim_whitespace           = True                                    # Trim any whitespace
-    strict_validation         = True                                    # Enable strict validation - new attribute
-    exact_length              = True                                    # Require exact length match - new attribute
+    allow_empty               = True                                   # Don't allow empty hash values
+    trim_whitespace           = True                                   # Trim any whitespace
+    strict_validation         = True                                   # Enable strict validation - new attribute
+    exact_length              = True                                   # Require exact length match - new attribute
 
 def safe_str_hash(value: Any) -> Safe_Str__Hash:
     if isinstance(value, str):

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/cryptography/hashes/Safe_Str__SHA1.py

@@ -21,6 +21,6 @@ class Safe_Str__SHA1(Safe_Str):
     regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
     max_length        = TYPE_SAFE_STR__GITHUB__SHA__LENGTH
     exact_length      = True
-    allow_empty       = False
+    allow_empty       = True
     trim_whitespace   = True
     strict_validation = True

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/cryptography/hashes/Safe_Str__SHA1__Short.py

@@ -19,6 +19,6 @@ class Safe_Str__SHA1__Short(Safe_Str):
     regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
     max_length        = TYPE_SAFE_STR__GITHUB__SHA_SHORT__LENGTH
     exact_length      = True
-    allow_empty       = False
+    allow_empty       = True
     trim_whitespace   = True
     strict_validation = True

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/cryptography/nacl/Safe_Str__NaCl__Private_Key.py

@@ -22,6 +22,6 @@ class Safe_Str__NaCl__Private_Key(Safe_Str):
     regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
     max_length        = TYPE_SAFE_STR__NACL__PRIVATE_KEY__LENGTH
     exact_length      = True
-    allow_empty       = False
+    allow_empty       = True
     trim_whitespace   = True
     strict_validation = True

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/cryptography/nacl/Safe_Str__NaCl__Public_Key.py

@@ -23,6 +23,6 @@ class Safe_Str__NaCl__Public_Key(Safe_Str):
     regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
     max_length        = TYPE_SAFE_STR__NACL__PUBLIC_KEY__LENGTH
     exact_length      = True
-    allow_empty       = False
+    allow_empty       = True
     trim_whitespace   = True
     strict_validation = True

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/filesystem/Safe_Str__File__Name.py

@@ -5,6 +5,6 @@ TYPE_SAFE_STR__FILE__NAME__REGEX = re.compile(r'[^a-zA-Z0-9_\-. ]')
 
 class Safe_Str__File__Name(Safe_Str):
     regex                      = TYPE_SAFE_STR__FILE__NAME__REGEX
-    allow_empty                = False
+    allow_empty                = True
     trim_whitespace            = True
     allow_all_replacement_char = False

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/git/Safe_Str__Git__Ref.py

@@ -24,7 +24,7 @@ class Safe_Str__Git__Ref(Safe_Str):
     - /repos/{owner}/{repo}/commits/{ref}
     """
     max_length      = 255
-    allow_empty     = False
+    allow_empty     = True
     trim_whitespace = True
 
     def __new__(cls, value=None):

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/git/Safe_Str__Git__Ref_Base.py

@@ -23,7 +23,7 @@ class Safe_Str__Git__Ref_Base(Safe_Str):
     """
     regex                      = TYPE_SAFE_STR__GIT_REF__REGEX
     max_length                 = TYPE_SAFE_STR__GIT_REF__MAX_LENGTH
-    allow_empty                = False
+    allow_empty                = True
     trim_whitespace            = True
     allow_all_replacement_char = True
 

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/git/Safe_Str__Version.py

@@ -9,7 +9,7 @@ class Safe_Str__Version(Safe_Str):
     regex             = TYPE_SAFE_STR__VERSION__REGEX
     regex_mode        =  Enum__Safe_Str__Regex_Mode.MATCH                                            # in this case we need an exact match of the version regex
     max_length        = TYPE_SAFE_STR__VERSION__MAX_LENGTH
-    allow_empty       = False
+    allow_empty       = True
     trim_whitespace   = True
     strict_validation = True                                                                        # Ensure the value exactly matches the regex
 

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/github/Safe_Str__GitHub__Repo.py

@@ -20,7 +20,7 @@ class Safe_Str__GitHub__Repo(Safe_Str):
     """
     regex                      = TYPE_SAFE_STR__GITHUB__REPO__REGEX
     max_length                 = TYPE_SAFE_STR__GITHUB__REPO__MAX_LENGTH
-    allow_empty                = False
+    allow_empty                = True
     trim_whitespace            = True
     allow_all_replacement_char = False
     repo_owner                 : Safe_Str__GitHub__Repo_Owner = None                                 # note: due to the str override these will not show in the Pycharm code hints (but they will work)
@@ -31,16 +31,20 @@ class Safe_Str__GitHub__Repo(Safe_Str):
         
         if result:
             if '/' not in result:                                                                   # Check for the required forward slash
-                raise ValueError(f"GitHub repository must be in 'owner/repo' format: {result}")
+                raise ValueError(f"in {cls.__name__}, gitHub repository must be in 'owner/repo' format: {result}")
             
 
             parts = result.split('/')                                                               # Split and validate components using the dedicated classes
             if len(parts) != 2:
-                raise ValueError(f"GitHub repository must be in 'owner/repo' format: {result}")
+                raise ValueError(f"in {cls.__name__}, gitHub repository must be in 'owner/repo' format: {result}")
             
             owner_part, repo_part = parts
 
             result.repo_owner = Safe_Str__GitHub__Repo_Owner(owner_part)                            # Validate using the dedicated classes (and store the references)
-            result.repo_name  = Safe_Str__GitHub__Repo_Name(repo_part  )                            # This will raise appropriate errors if validation fails
+            result.repo_name  = Safe_Str__GitHub__Repo_Name(repo_part  )
+            if not result.repo_owner:
+                raise ValueError(f"in {cls.__name__}, missing owner, gitHub repository must be in 'owner/repo' format: {result}")
+            if not result.repo_name:
+                raise ValueError(f"in {cls.__name__}, missing name, gitHub repository must be in 'owner/repo' format: {result}")
         
         return result

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/github/Safe_Str__GitHub__Repo_Name.py

@@ -15,7 +15,7 @@ class Safe_Str__GitHub__Repo_Name(Safe_Str):
     """
     regex                      = TYPE_SAFE_STR__GITHUB__REPO_NAME__REGEX
     max_length                 = TYPE_SAFE_STR__GITHUB__REPO_NAME__MAX_LENGTH
-    allow_empty                = False
+    allow_empty                = True
     trim_whitespace            = True
     allow_all_replacement_char = False
 
@@ -26,10 +26,10 @@ class Safe_Str__GitHub__Repo_Name(Safe_Str):
         if result:
             # Check if it's just periods (reserved names)
             if result in ['.', '..']:
-                raise ValueError(f"Invalid repository name: {result}")
+                raise ValueError(f"in {cls.__name__}, invalid repository name: {result}")
 
             # Check for all replacement characters
             if set(result) == {'_'} and len(result) > 0:
-                raise ValueError(f"Invalid repository name: {result}")
+                raise ValueError(f"in {cls.__name__}, invalid repository name: {result}")
 
         return result

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/github/Safe_Str__GitHub__Repo_Owner.py

@@ -16,7 +16,7 @@ class Safe_Str__GitHub__Repo_Owner(Safe_Str):
     """
     regex                      = TYPE_SAFE_STR__GITHUB__REPO_OWNER__REGEX
     max_length                 = TYPE_SAFE_STR__GITHUB__REPO_OWNER__MAX_LENGTH
-    allow_empty                = False
+    allow_empty                = True
     trim_whitespace            = True
     allow_all_replacement_char = False
 
@@ -26,13 +26,13 @@ class Safe_Str__GitHub__Repo_Owner(Safe_Str):
 
         if result:                                                                                  # Additional GitHub-specific validation
             if result.startswith('-') or result.endswith('-'):                                      # Check for leading/trailing hyphens
-                raise ValueError(f"GitHub owner name cannot start or end with a hyphen: {result}")
+                raise ValueError(f"in {cls.__name__}, gitHub owner name cannot start or end with a hyphen: {result}")
 
             if '--' in result:                                                                      # Check for consecutive hyphens
-                raise ValueError(f"GitHub owner name cannot contain consecutive hyphens: {result}")
+                raise ValueError(f"in {cls.__name__}, gitHub owner name cannot contain consecutive hyphens: {result}")
 
             if result.replace('_', '') == '':                                                       # Check for all underscores (sanitized invalid input)
-                raise ValueError(f"Invalid GitHub owner name: {result}")
+                raise ValueError(f"in {cls.__name__}, invalid GitHub owner name: {result}")
 
         return result
 

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/primitives/safe_str/http/Safe_Str__Http__Content_Type.py

@@ -7,6 +7,6 @@ TYPE_SAFE_STR__HTTP__CONTENT_TYPE__MAX_LENGTH = 256
 class Safe_Str__Http__Content_Type(Safe_Str):
     regex                      = TYPE_SAFE_STR__HTTP__CONTENT_TYPE__REGEX
     max_length                 = TYPE_SAFE_STR__HTTP__CONTENT_TYPE__MAX_LENGTH
-    allow_empty                = False
+    allow_empty                = True
     trim_whitespace            = True
     allow_all_replacement_char = False

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Dict.py

@@ -1,5 +1,6 @@
 from typing                                                           import Type
 from osbot_utils.type_safe.Type_Safe__Base                            import Type_Safe__Base
+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
 
 
@@ -35,7 +36,8 @@ class Type_Safe__Dict(Type_Safe__Base, dict):
 
             if isinstance(key, (type, Type)):                                                     # Handle Type objects as keys
                 key = f"{key.__module__}.{key.__name__}"
-
+            elif isinstance(key, Type_Safe__Primitive):
+                key = key.__to_primitive__()
             if isinstance(value, Type_Safe):                                                # Handle Type_Safe objects in values
                 result[key] = value.json()
             elif isinstance(value, (list, tuple)):                                          # Handle lists/tuples that might contain Type_Safe objects
@@ -44,8 +46,11 @@ class Type_Safe__Dict(Type_Safe__Base, dict):
             elif isinstance(value, dict):                                                   # Handle nested dictionaries that might contain Type_Safe objects
                 result[key] = {k: v.json() if isinstance(v, Type_Safe) else v
                                for k, v in value.items()}
-            else:                                                                           # Regular values can be used as-is
-                result[key] = value
+            else:
+                if isinstance(value, Type_Safe__Primitive):
+                    result[key] = value.__to_primitive__()
+                else:
+                    result[key] = value
         return result
 
     def keys(self) -> Type_Safe__List:

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/type_safe_core/collections/Type_Safe__List.py

@@ -50,6 +50,8 @@ class Type_Safe__List(Type_Safe__Base, list):
         for item in self:
             if isinstance(item, Type_Safe):
                 result.append(item.json())
+            elif isinstance(item, Type_Safe__Primitive):
+                result.append(item.__to_primitive__())
             elif isinstance(item, (list, tuple)):
                 result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])
             elif isinstance(item, dict):

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Set.py

@@ -1,4 +1,6 @@
 from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base, type_str
+from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
+
 
 class Type_Safe__Set(Type_Safe__Base, set):
     def __init__(self, expected_type, *args):
@@ -10,10 +12,21 @@ class Type_Safe__Set(Type_Safe__Base, set):
         return f"set[{expected_type_name}] with {len(self)} elements"
 
     def add(self, item):
-        try:
+        from osbot_utils.type_safe.Type_Safe import Type_Safe
+        if type(self.expected_type) is type and issubclass(self.expected_type, Type_Safe) and type(item) is dict:       # Handle Type_Safe objects from dicts
+            item = self.expected_type.from_json(item)
+        elif type(self.expected_type) is type and issubclass(self.expected_type, Type_Safe__Primitive):                 # Handle Type_Safe__Primitive conversions (str -> Safe_Str, etc.)
+            if not isinstance(item, self.expected_type):
+                try:
+                    item = self.expected_type(item)
+                except (ValueError, TypeError) as e:
+                    raise TypeError(f"In Type_Safe__Set: Could not convert {type(item).__name__} to {self.expected_type.__name__}: {e}") from None
+
+        try:                                                                                                            # Now validate the (possibly converted) item
             self.is_instance_of_type(item, self.expected_type)
         except TypeError as e:
-            raise TypeError(f"In Type_Safe__Set: Invalid type for item: {e}")
+            raise TypeError(f"In Type_Safe__Set: Invalid type for item: {e}") from None
+
         super().add(item)
 
     def json(self):
@@ -23,6 +36,8 @@ class Type_Safe__Set(Type_Safe__Base, set):
         for item in self:
             if isinstance(item, Type_Safe):
                 result.append(item.json())
+            elif isinstance(item, Type_Safe__Primitive):
+                result.append(item.__to_primitive__())
             elif isinstance(item, (list, tuple, set)):
                 result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])
             elif isinstance(item, dict):

osbot_utils-2.86.0/osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Tuple.py

@@ -0,0 +1,74 @@
+from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base, type_str
+
+class Type_Safe__Tuple(Type_Safe__Base, tuple):
+
+    def __new__(cls, expected_types, items=None):
+        items = items or tuple()
+
+        converted_items = cls.convert_items(expected_types, items)                  # Convert items BEFORE creating the tuple
+
+        instance = super().__new__(cls, converted_items)
+        instance.expected_types = expected_types
+        return instance
+
+    def __init__(self, expected_types, items=None):
+        if items:
+            self.validate_items(self)                                               # Validate the already-converted items
+
+    @classmethod
+    def convert_items(cls, expected_types, items):                                  # Convert items to expected types before creating the tuple.
+        from osbot_utils.type_safe.Type_Safe            import Type_Safe
+        from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
+
+        if not items:
+            return tuple()
+
+        if len(items) != len(expected_types):
+            raise ValueError(f"Expected {len(expected_types)} elements, got {len(items)}")
+
+
+        converted = []
+        for item, expected_type in zip(items, expected_types):
+            if type(expected_type) is type and issubclass(expected_type, Type_Safe) and type(item) is dict: # Handle Type_Safe objects from dicts
+                item = expected_type.from_json(item)
+            elif type(expected_type) is type and issubclass(expected_type, Type_Safe__Primitive):           # Handle Type_Safe__Primitive conversions
+                if not isinstance(item, expected_type):
+                    try:
+                        item = expected_type(item)
+                    except (ValueError, TypeError) as e:
+                        raise TypeError(f"In Type_Safe__Tuple: Could not convert {type(item).__name__} to {expected_type.__name__}: {e}") from None
+
+            converted.append(item)
+
+        return tuple(converted)
+
+    def validate_items(self, items):
+        if len(items) != len(self.expected_types):
+            raise ValueError(f"Expected {len(self.expected_types)} elements, got {len(items)}")
+        for item, expected_type in zip(items, self.expected_types):
+            try:
+                self.is_instance_of_type(item, expected_type)
+            except TypeError as e:
+                raise TypeError(f"In Type_Safe__Tuple: Invalid type for item: {e}")
+
+    def __repr__(self):
+        types_str = ', '.join(type_str(t) for t in self.expected_types)
+        return f"tuple[{types_str}] with {len(self)} elements"
+
+    def json(self):
+        from osbot_utils.type_safe.Type_Safe            import Type_Safe
+        from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
+
+        result = []
+        for item in self:
+            if isinstance(item, Type_Safe):
+                result.append(item.json())
+            elif isinstance(item, Type_Safe__Primitive):
+                result.append(item.__to_primitive__())  # Convert primitives to base types
+            elif isinstance(item, (list, tuple)):
+                result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])
+            elif isinstance(item, dict):
+                result.append({k: v.json() if isinstance(v, Type_Safe) else v for k, v in item.items()})
+            else:
+                result.append(item)
+        return result

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__From_Json.py

@@ -10,6 +10,7 @@ from osbot_utils.type_safe.primitives.safe_str.cryptography.hashes.Safe_Str__Has
 from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Dict             import Type_Safe__Dict
 from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List             import Type_Safe__List
 from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Set              import Type_Safe__Set
+from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Tuple            import Type_Safe__Tuple
 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
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Convert               import type_safe_convert
@@ -60,8 +61,11 @@ class Type_Safe__Step__From_Json:
                     elif annotation_origin == type:                                         # Handle type objects inside ForwardRef
                         value = self.deserialize_type__using_value(value)
                     if annotation_origin is tuple and isinstance(value, list):
-                        # item_types = get_args(annotation)   # todo: see if we should do type safety here
-                        value = tuple(value)
+                        item_types = get_args(annotation)
+                        if item_types:
+                            value = Type_Safe__Tuple(expected_types=item_types, items=value)                # Create a Type_Safe__Tuple with proper type conversion
+                        else:
+                            value = tuple(value)
                     elif type_safe_annotations.obj_is_attribute_annotation_of_type(_self, key, dict):                                # handle the case when the value is a dict
                         value = self.deserialize_dict__using_key_value_annotations(_self, key, value)
                     elif type_safe_annotations.obj_is_attribute_annotation_of_type(_self, key, set):                              # handle the case when the value is a list

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Set_Attr.py

@@ -13,6 +13,8 @@ class Type_Safe__Step__Set_Attr:
             value = self.resolve_value__dict(_self, name, value)
         elif type(value) is list:
             value = self.resolve_value__list(_self, name, value)
+        elif type(value) is tuple:
+            value = self.resolve_value__tuple(_self, name, value)
         elif isinstance(annotations.get(name), type) and issubclass(annotations.get(name), Type_Safe__Primitive) and type(value) in (int, str, float):
             return annotations.get(name)(value)
         elif type(value) in (int, str):                                                   # for now only a small number of str and int classes are supported (until we understand the full implications of this)
@@ -53,6 +55,20 @@ class Type_Safe__Step__Set_Attr:
                     return type_safe_list
 
         return value
+
+    def resolve_value__tuple(self, _self, name, value):                 # Convert regular tuples to Type_Safe__Tuple instances
+        annotations = type_safe_cache.get_obj_annotations(_self)
+        annotation = annotations.get(name)
+
+        if annotation:
+            origin = type_safe_cache.get_origin(annotation)
+            if origin is tuple:
+                args = get_args(annotation)
+                if args:
+                    from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Tuple import Type_Safe__Tuple
+                    return Type_Safe__Tuple(expected_types=args, items=value)
+
+        return value
     def resolve_value__from_origin(self, value):
         #origin = type_safe_cache.get_origin(value)                                     # todo: figure out why this is the only place that the type_safe_cache.get_origin doesn't work (due to WeakKeyDictionary key error on value)
         origin = get_origin(value)
@@ -106,7 +122,7 @@ class Type_Safe__Step__Set_Attr:
             return _super.__setattr__(name, value)
 
         if value is not None:
-            value = self.resolve_value          (_self, annotations, name, value)
+            value = self.resolve_value   (_self, annotations, name, value)
             value = self.handle_get_class(_self, annotations, name, value)
         else:
             type_safe_validation.validate_if_value_has_been_set(_self, annotations, name, value)

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/osbot_utils/utils/Objects.py

@@ -265,14 +265,18 @@ def pickle_load_from_bytes(pickled_data: bytes):
             return {}
 
 # todo: see if it is possible to add recursive protection to this logic
+# todo: we should move this method to the type_safe classes and folders
 def serialize_to_dict(obj):
-    from decimal import Decimal
-    from enum    import Enum
-    from typing  import List
-
-    if hasattr(obj, '__primitive_base__') and isinstance(obj, (str, int, float)):
+    from decimal                               import Decimal
+    from enum                                  import Enum
+    from typing                                import List
+    from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base
+
+    if isinstance(obj, Type_Safe__Base) and hasattr(obj, 'json'):                                   # if it is one of these Type_Safe__Base  classes
+        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, (str, int, float, bool, bytes, Decimal)) or obj is None:     # todo: add support for objects like datetime
+    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

osbot_utils-2.86.0/osbot_utils/version

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

{osbot_utils-2.84.0 → osbot_utils-2.86.0}/pyproject.toml

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

osbot_utils-2.84.0/osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Tuple.py

@@ -1,41 +0,0 @@
-from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base, type_str
-
-class Type_Safe__Tuple(Type_Safe__Base, tuple):
-
-    def __new__(cls, expected_types, items=None):
-        items    = items or tuple()
-        instance = super().__new__(cls, items)
-        instance.expected_types = expected_types
-        return instance
-
-    def __init__(self, expected_types, items=None):             # todo: see if we should be assigning expected_types to self here
-        if items:
-            self.validate_items(items)
-
-    def validate_items(self, items):
-        if len(items) != len(self.expected_types):
-            raise ValueError(f"Expected {len(self.expected_types)} elements, got {len(items)}")
-        for item, expected_type in zip(items, self.expected_types):
-            try:
-                self.is_instance_of_type(item, expected_type)
-            except TypeError as e:
-                raise TypeError(f"In Type_Safe__Tuple: Invalid type for item: {e}")
-
-    def __repr__(self):
-        types_str = ', '.join(type_str(t) for t in self.expected_types)
-        return f"tuple[{types_str}] with {len(self)} elements"
-
-    def json(self):
-        from osbot_utils.type_safe.Type_Safe import Type_Safe
-
-        result = []
-        for item in self:
-            if isinstance(item, Type_Safe):
-                result.append(item.json())
-            elif isinstance(item, (list, tuple)):
-                result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])
-            elif isinstance(item, dict):
-                result.append({k: v.json() if isinstance(v, Type_Safe) else v for k, v in item.items()})
-            else:
-                result.append(item)
-        return result

osbot_utils-2.84.0/osbot_utils/version

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