osbot-utils 1.88.0__tar.gz → 1.89.0__tar.gz

{osbot_utils-1.88.0 → osbot_utils-1.89.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.88.0
+Version: 1.89.0
 Summary: OWASP Security Bot - Utils
 Home-page: https://github.com/owasp-sbot/OSBot-Utils
 License: MIT
@@ -23,7 +23,7 @@ Description-Content-Type: text/markdown
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v1.88.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.89.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 

{osbot_utils-1.88.0 → osbot_utils-1.89.0}/README.md

@@ -2,7 +2,7 @@
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v1.88.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.89.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 

{osbot_utils-1.88.0 → osbot_utils-1.89.0}/osbot_utils/base_classes/Type_Safe.py

@@ -3,7 +3,7 @@
 
 import sys
 import types
-from osbot_utils.utils.Objects import default_value         # todo: remove test mocking requirement for this to be here (instead of on the respective method)
+from osbot_utils.utils.Objects                  import default_value         # todo: remove test mocking requirement for this to be here (instead of on the respective method)
 
 # Backport implementations of get_origin and get_args for Python 3.7
 if sys.version_info < (3, 8):                                           # pragma: no cover
@@ -23,7 +23,7 @@ if sys.version_info < (3, 8):                                           # pragma
         else:
             return ()
 else:
-    from typing import get_origin, get_args
+    from typing import get_origin, get_args, ForwardRef
 
 if sys.version_info >= (3, 10):
     NoneType = types.NoneType
@@ -148,6 +148,7 @@ class Type_Safe:
     def __default__value__(cls, var_type):
         import typing
         from osbot_utils.base_classes.Type_Safe__List import Type_Safe__List
+        from osbot_utils.base_classes.Type_Safe__Dict import Type_Safe__Dict
 
         if var_type is typing.Set:                              # todo: refactor the dict, set and list logic, since they are 90% the same
             return set()
@@ -156,13 +157,28 @@ class Type_Safe:
 
         if var_type is typing.Dict:
             return {}
-        if get_origin(var_type) is dict:
-            return {}                                           # todo: add Type_Safe__Dict
+
+        if get_origin(var_type) is dict:                        # e.g. Dict[key_type, value_type]
+            key_type, value_type = get_args(var_type)
+            if isinstance(key_type, ForwardRef):                # Handle forward references on key_type ---
+                forward_name = key_type.__forward_arg__
+                if forward_name == cls.__name__:
+                    key_type = cls
+            if isinstance(value_type, ForwardRef):              # Handle forward references on value_type ---
+                forward_name = value_type.__forward_arg__
+                if forward_name == cls.__name__:
+                    value_type = cls
+            return Type_Safe__Dict(expected_key_type=key_type, expected_value_type=value_type)
 
         if var_type is typing.List:
-            return []  # handle case when List was used with no type information provided
+            return []                                           # handle case when List was used with no type information provided
+
         if get_origin(var_type) is list:                        # if we have list defined as list[type]
             item_type = get_args(var_type)[0]                   #    get the type that was defined
+            if isinstance(item_type, ForwardRef):               # handle the case when the type is a forward reference
+                forward_name = item_type.__forward_arg__
+                if forward_name == cls.__name__:                #    if the forward reference is to the current class (simple name check)
+                    item_type = cls                            #       set the item_type to the current class
             return Type_Safe__List(expected_type=item_type)     #    and used it as expected_type in Type_Safe__List
         else:
             return default_value(var_type)                      # for all other cases call default_value, which will try to create a default instance
@@ -258,16 +274,16 @@ class Type_Safe:
         return self
 
     def deserialize_dict__using_key_value_annotations(self, key, value):
+        from osbot_utils.base_classes.Type_Safe__Dict import Type_Safe__Dict
+
         dict_annotations_tuple =  get_args(self.__annotations__[key])
         if not dict_annotations_tuple:                                      # happens when the value is a dict/Dict with no annotations
             return value
         if not type(value) is dict:
             return value
-        #key_class   = get_args(self.__annotations__[key])[0]
-        #value_class = get_args(self.__annotations__[key])[1]
         key_class   = dict_annotations_tuple[0]
         value_class = dict_annotations_tuple[1]
-        new_value   = {}
+        new_value   = Type_Safe__Dict(expected_key_type=key_class, expected_value_type=value_class)
 
         for dict_key, dict_value in value.items():
             if issubclass(key_class, Type_Safe):

osbot_utils-1.88.0/osbot_utils/base_classes/Type_Safe__List.py → osbot_utils-1.89.0/osbot_utils/base_classes/Type_Safe__Base.py

@@ -2,23 +2,7 @@ from typing import get_origin, get_args, Union, Optional, Any, ForwardRef
 
 EXACT_TYPE_MATCH = (int, float, str, bytes, bool, complex)
 
-class Type_Safe__List(list):
-
-    def __init__(self, expected_type, *args):
-        super().__init__(*args)
-        self.expected_type = expected_type
-
-    def __repr__(self):
-        expected_type_name = type_str(self.expected_type)
-        return f"list[{expected_type_name}] with {len(self)} elements"
-
-    def append(self, item):
-        try:
-            self.is_instance_of_type(item, self.expected_type)
-        except TypeError as e:
-            raise TypeError(f"In Type_Safe__List: Invalid type for item: {e}")
-        super().append(item)
-
+class Type_Safe__Base:
     def is_instance_of_type(self, item, expected_type):
         if expected_type is Any:
             return True
@@ -130,4 +114,4 @@ def get_object_type_str(obj):
         elem_type_str = ', '.join(sorted(elem_types))
         return f"List[{elem_type_str}]"
     else:
-        return type(obj).__name__
+        return type(obj).__name__

osbot_utils-1.89.0/osbot_utils/base_classes/Type_Safe__Dict.py

@@ -0,0 +1,22 @@
+from osbot_utils.base_classes.Type_Safe__Base import type_str, Type_Safe__Base
+
+class Type_Safe__Dict(Type_Safe__Base, dict):
+    def __init__(self, expected_key_type, expected_value_type, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.expected_key_type   = expected_key_type
+        self.expected_value_type = expected_value_type
+
+        for k, v in self.items():                           # check type-safety of ctor arguments
+            self.is_instance_of_type(k, self.expected_key_type  )
+            self.is_instance_of_type(v, self.expected_value_type)
+
+    def __setitem__(self, key, value):                                  # Check type-safety before allowing assignment.
+        self.is_instance_of_type(key, self.expected_key_type)
+        self.is_instance_of_type(value, self.expected_value_type)
+        super().__setitem__(key, value)
+
+    def __repr__(self):
+        key_type_name   = type_str(self.expected_key_type)
+        value_type_name = type_str(self.expected_value_type)
+        return f"dict[{key_type_name}, {value_type_name}] with {len(self)} entries"

osbot_utils-1.89.0/osbot_utils/base_classes/Type_Safe__List.py

@@ -0,0 +1,22 @@
+from osbot_utils.base_classes.Type_Safe__Base import Type_Safe__Base, type_str
+
+
+class Type_Safe__List(Type_Safe__Base, list):
+
+    def __init__(self, expected_type, *args):
+        super().__init__(*args)
+        self.expected_type = expected_type
+
+    def __repr__(self):
+        expected_type_name = type_str(self.expected_type)
+        return f"list[{expected_type_name}] with {len(self)} elements"
+
+    def append(self, item):
+        try:
+            self.is_instance_of_type(item, self.expected_type)
+        except TypeError as e:
+            raise TypeError(f"In Type_Safe__List: Invalid type for item: {e}")
+        super().append(item)
+
+
+

osbot_utils-1.89.0/osbot_utils/helpers/Xml_To_Dict.py

@@ -0,0 +1,87 @@
+from typing                 import Dict, Any, Union
+from xml.etree.ElementTree  import Element
+
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+
+class XML_Attribute(Type_Safe):
+    name     : str
+    value    : str
+    namespace: str
+
+class XML_Element(Type_Safe):
+    attributes: Dict[str, XML_Attribute]
+    children  : Dict[str, Union[str, 'XML_Element']]
+
+
+class Xml_To_Dict(Type_Safe):
+    xml_data    : str             = None       # Input XML string
+    root        : Element         = None       # Root ElementTree.Element
+    namespaces  : Dict[str, str]               # XML namespaces
+    xml_dict    : Dict[str, Any]               # Parsed XML as dictionary
+
+    def setup(self) :
+        from xml.etree.ElementTree import ParseError
+        try:
+            self.load_namespaces()
+            self.load_root()
+
+        except ParseError as e:
+            raise ValueError(f"Invalid XML: {str(e)}")
+        return self
+
+
+    def load_namespaces(self):
+        from xml.etree.ElementTree import iterparse
+        from io import StringIO
+
+        for event, elem in iterparse(StringIO(self.xml_data), events=("start-ns",)):
+            self.namespaces[elem[0]] = elem[1]
+
+    def load_root(self):
+        from xml.etree.ElementTree import fromstring
+
+        self.root = fromstring(self.xml_data)
+
+    def element_to_dict(self, element: Element) -> Union[Dict[str, Any], str]:
+        """Convert an ElementTree.Element to a dictionary"""
+        result: Dict[str, Any] = {}
+
+
+        if element.attrib:                                  # Handle attributes
+            result.update(element.attrib)
+
+        # Handle child elements
+        child_nodes: Dict[str, Any] = {}
+        for child in element:
+            tag = child.tag                                 # Remove namespace prefix if present
+            if '}' in tag:
+                tag = tag.split('}', 1)[1]
+
+            child_data = self.element_to_dict(child)
+
+            if tag in child_nodes:
+                if not isinstance(child_nodes[tag], list):
+                    child_nodes[tag] = [child_nodes[tag]]
+                child_nodes[tag].append(child_data)
+            else:
+                child_nodes[tag] = child_data
+
+        # Handle text content
+        text = element.text.strip() if element.text else ''
+        if text:
+            if child_nodes or result:
+                result['_text'] = text
+            else:
+                return text
+        elif not child_nodes and not result:                # Make sure we return text content even for empty nodes
+            return text
+
+        # Combine results
+        if child_nodes:
+            result.update(child_nodes)
+
+        return result
+
+    def parse(self) -> Dict[str, Any]:   # Convert parsed XML to dictionary
+        self.xml_dict = self.element_to_dict(self.root)
+        return self

{osbot_utils-1.88.0 → osbot_utils-1.89.0}/osbot_utils/utils/Objects.py

@@ -30,14 +30,17 @@ def are_types_compatible_for_assigment(source_type, target_type):
     import types
     import typing
 
+    if isinstance(target_type, str):                                    # If the "target_type" is a forward reference (string), handle it here.
+        if target_type == source_type.__name__:                         # Simple check: does the string match the actual class name
+            return True
     if source_type is target_type:
         return True
     if source_type is int and target_type is float:
         return True
-    if target_type in source_type.__mro__:          # this means that the source_type has the target_type has of its base types
+    if target_type in source_type.__mro__:                              # this means that the source_type has the target_type has of its base types
         return True
-    if target_type is callable:                     # handle case where callable was used as the target type
-        if source_type is types.MethodType:         #     and a method or function was used as the source type
+    if target_type is callable:                                         # handle case where callable was used as the target type
+        if source_type is types.MethodType:                             #     and a method or function was used as the source type
             return True
         if source_type is types.FunctionType:
             return True
@@ -413,7 +416,7 @@ def value_type_matches_obj_annotation_for_attr(target, attr_name, value):
                 origin_attr_type = get_origin(attr_type)                # to handle when type definion contains an generic
                 if origin_attr_type is typing.Union:
                     args = get_args(attr_type)
-                    if len(args)==2 and args[1] is type(None):          # todo: find a better way to do this, since this is handling an edge case when origin_attr_type is Optional (whcih is an shorthand for Union[X, None] )
+                    if len(args)==2 and args[1] is type(None):          # todo: find a better way to do this, since this is handling an edge case when origin_attr_type is Optional (which is an shorthand for Union[X, None] )
                         attr_type = args[0]
                         origin_attr_type = get_origin(attr_type)
 

osbot_utils-1.89.0/osbot_utils/version

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

{osbot_utils-1.88.0 → osbot_utils-1.89.0}/pyproject.toml

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

osbot_utils-1.88.0/osbot_utils/version

@@ -1 +0,0 @@
-v1.88.0