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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.85.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.85.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.85.0 → osbot_utils-2.86.0}/README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.85.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.85.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.85.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.85.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.85.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.85.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.85.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.85.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.85.0 → osbot_utils-2.86.0}/pyproject.toml

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

osbot_utils-2.85.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.85.0/osbot_utils/version

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