osbot-utils 1.88.0__py3-none-any.whl → 1.90.0__py3-none-any.whl

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/base_classes/Type_Safe__Base.py

@@ -0,0 +1,117 @@
+from typing import get_origin, get_args, Union, Optional, Any, ForwardRef
+
+EXACT_TYPE_MATCH = (int, float, str, bytes, bool, complex)
+
+class Type_Safe__Base:
+    def is_instance_of_type(self, item, expected_type):
+        if expected_type is Any:
+            return True
+        if isinstance(expected_type, ForwardRef):               # todo: add support for ForwardRef
+            return True
+        origin = get_origin(expected_type)
+        args   = get_args(expected_type)
+        if origin is None:
+            if expected_type in EXACT_TYPE_MATCH:
+                if type(item) is expected_type:
+                    return True
+                else:
+                    expected_type_name = type_str(expected_type)
+                    actual_type_name = type_str(type(item))
+                    raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            else:
+                if isinstance(item, expected_type):                                 # Non-parameterized type
+                    return True
+                else:
+                    expected_type_name = type_str(expected_type)
+                    actual_type_name   = type_str(type(item))
+                    raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+
+        elif origin is list and args:                                                    # Expected type is List[...]
+            (item_type,) = args
+            if not isinstance(item, list):
+                expected_type_name = type_str(expected_type)
+                actual_type_name   = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            for idx, elem in enumerate(item):
+                try:
+                    self.is_instance_of_type(elem, item_type)
+                except TypeError as e:
+                    raise TypeError(f"In list at index {idx}: {e}")
+            return True
+        elif origin is dict and args:                                                    # Expected type is Dict[...]
+            key_type, value_type = args
+            if not isinstance(item, dict):
+                expected_type_name = type_str(expected_type)
+                actual_type_name   = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            for k, v in item.items():
+                try:
+                    self.is_instance_of_type(k, key_type)
+                except TypeError as e:
+                    raise TypeError(f"In dict key '{k}': {e}")
+                try:
+                    self.is_instance_of_type(v, value_type)
+                except TypeError as e:
+                    raise TypeError(f"In dict value for key '{k}': {e}")
+            return True
+        elif origin is tuple:
+            if not isinstance(item, tuple):
+                expected_type_name = type_str(expected_type)
+                actual_type_name = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            if len(args) != len(item):
+                raise TypeError(f"Expected tuple of length {len(args)}, but got {len(item)}")
+            for idx, (elem, elem_type) in enumerate(zip(item, args)):
+                try:
+                    self.is_instance_of_type(elem, elem_type)
+                except TypeError as e:
+                    raise TypeError(f"In tuple at index {idx}: {e}")
+            return True
+        elif origin is Union or expected_type is Optional:                                                   # Expected type is Union[...]
+            for arg in args:
+                try:
+                    self.is_instance_of_type(item, arg)
+                    return True
+                except TypeError:
+                    continue
+            expected_type_name = type_str(expected_type)
+            actual_type_name   = type_str(type(item))
+            raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+        else:
+            if isinstance(item, origin):
+                return True
+            else:
+                expected_type_name = type_str(expected_type)
+                actual_type_name = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+
+# todo: see if we should/can move this to the Objects.py file
+def type_str(tp):
+    origin = get_origin(tp)
+    if origin is None:
+        if hasattr(tp, '__name__'):
+            return tp.__name__
+        else:
+            return str(tp)
+    else:
+        args = get_args(tp)
+        args_str = ', '.join(type_str(arg) for arg in args)
+        return f"{origin.__name__}[{args_str}]"
+
+def get_object_type_str(obj):
+    if isinstance(obj, dict):
+        if not obj:
+            return "Dict[Empty]"
+        key_types      = set(type(k).__name__ for k in obj.keys())
+        value_types    = set(type(v).__name__ for v in obj.values())
+        key_type_str   = ', '.join(sorted(key_types))
+        value_type_str = ', '.join(sorted(value_types))
+        return f"Dict[{key_type_str}, {value_type_str}]"
+    elif isinstance(obj, list):
+        if not obj:
+            return "List[Empty]"
+        elem_types = set(type(e).__name__ for e in obj)
+        elem_type_str = ', '.join(sorted(elem_types))
+        return f"List[{elem_type_str}]"
+    else:
+        return type(obj).__name__

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/base_classes/Type_Safe__List.py

@@ -1,8 +1,7 @@
-from typing import get_origin, get_args, Union, Optional, Any, ForwardRef
+from osbot_utils.base_classes.Type_Safe__Base import Type_Safe__Base, type_str
 
-EXACT_TYPE_MATCH = (int, float, str, bytes, bool, complex)
 
-class Type_Safe__List(list):
+class Type_Safe__List(Type_Safe__Base, list):
 
     def __init__(self, expected_type, *args):
         super().__init__(*args)
@@ -19,115 +18,5 @@ class Type_Safe__List(list):
             raise TypeError(f"In Type_Safe__List: Invalid type for item: {e}")
         super().append(item)
 
-    def is_instance_of_type(self, item, expected_type):
-        if expected_type is Any:
-            return True
-        if isinstance(expected_type, ForwardRef):               # todo: add support for ForwardRef
-            return True
-        origin = get_origin(expected_type)
-        args   = get_args(expected_type)
-        if origin is None:
-            if expected_type in EXACT_TYPE_MATCH:
-                if type(item) is expected_type:
-                    return True
-                else:
-                    expected_type_name = type_str(expected_type)
-                    actual_type_name = type_str(type(item))
-                    raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
-            else:
-                if isinstance(item, expected_type):                                 # Non-parameterized type
-                    return True
-                else:
-                    expected_type_name = type_str(expected_type)
-                    actual_type_name   = type_str(type(item))
-                    raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
 
-        elif origin is list and args:                                                    # Expected type is List[...]
-            (item_type,) = args
-            if not isinstance(item, list):
-                expected_type_name = type_str(expected_type)
-                actual_type_name   = type_str(type(item))
-                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
-            for idx, elem in enumerate(item):
-                try:
-                    self.is_instance_of_type(elem, item_type)
-                except TypeError as e:
-                    raise TypeError(f"In list at index {idx}: {e}")
-            return True
-        elif origin is dict and args:                                                    # Expected type is Dict[...]
-            key_type, value_type = args
-            if not isinstance(item, dict):
-                expected_type_name = type_str(expected_type)
-                actual_type_name   = type_str(type(item))
-                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
-            for k, v in item.items():
-                try:
-                    self.is_instance_of_type(k, key_type)
-                except TypeError as e:
-                    raise TypeError(f"In dict key '{k}': {e}")
-                try:
-                    self.is_instance_of_type(v, value_type)
-                except TypeError as e:
-                    raise TypeError(f"In dict value for key '{k}': {e}")
-            return True
-        elif origin is tuple:
-            if not isinstance(item, tuple):
-                expected_type_name = type_str(expected_type)
-                actual_type_name = type_str(type(item))
-                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
-            if len(args) != len(item):
-                raise TypeError(f"Expected tuple of length {len(args)}, but got {len(item)}")
-            for idx, (elem, elem_type) in enumerate(zip(item, args)):
-                try:
-                    self.is_instance_of_type(elem, elem_type)
-                except TypeError as e:
-                    raise TypeError(f"In tuple at index {idx}: {e}")
-            return True
-        elif origin is Union or expected_type is Optional:                                                   # Expected type is Union[...]
-            for arg in args:
-                try:
-                    self.is_instance_of_type(item, arg)
-                    return True
-                except TypeError:
-                    continue
-            expected_type_name = type_str(expected_type)
-            actual_type_name   = type_str(type(item))
-            raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
-        else:
-            if isinstance(item, origin):
-                return True
-            else:
-                expected_type_name = type_str(expected_type)
-                actual_type_name = type_str(type(item))
-                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
 
-# todo: see if we should/can move this to the Objects.py file
-def type_str(tp):
-    origin = get_origin(tp)
-    if origin is None:
-        if hasattr(tp, '__name__'):
-            return tp.__name__
-        else:
-            return str(tp)
-    else:
-        args = get_args(tp)
-        args_str = ', '.join(type_str(arg) for arg in args)
-        return f"{origin.__name__}[{args_str}]"
-
-def get_object_type_str(obj):
-    if isinstance(obj, dict):
-        if not obj:
-            return "Dict[Empty]"
-        key_types      = set(type(k).__name__ for k in obj.keys())
-        value_types    = set(type(v).__name__ for v in obj.values())
-        key_type_str   = ', '.join(sorted(key_types))
-        value_type_str = ', '.join(sorted(value_types))
-        return f"Dict[{key_type_str}, {value_type_str}]"
-    elif isinstance(obj, list):
-        if not obj:
-            return "List[Empty]"
-        elem_types = set(type(e).__name__ for e in obj)
-        elem_type_str = ', '.join(sorted(elem_types))
-        return f"List[{elem_type_str}]"
-    else:
-        return type(obj).__name__

osbot_utils/helpers/xml/Xml__Attribute.py

@@ -0,0 +1,7 @@
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+
+
+class Xml__Attribute(Type_Safe):
+    name     : str
+    value    : str
+    namespace: str

osbot_utils/helpers/xml/Xml__Element.py

@@ -0,0 +1,15 @@
+from typing                                 import Dict, List, Union
+from osbot_utils.base_classes.Type_Safe     import Type_Safe
+from osbot_utils.helpers.xml.Xml__Attribute import Xml__Attribute
+
+class XML__Element(Type_Safe):
+    tag             : str                                   # Element's local name
+    namespace       : str                                   # Element's namespace URI
+    namespace_prefix: str                                   # Element's namespace prefix
+    attributes      : Dict[str, Xml__Attribute]             # Element attributes
+    children        : List[Union[str, 'XML__Element']]      # Child elements/text
+
+    # def qualified_name(self) -> str:                        # Get fully qualified name with prefix
+    #     if self.namespace_prefix:
+    #         return f"{self.namespace_prefix}:{self.tag}"
+    #     return self.tag

osbot_utils/helpers/xml/Xml__File.py

@@ -0,0 +1,9 @@
+from typing                                 import Dict
+from osbot_utils.base_classes.Type_Safe     import Type_Safe
+from osbot_utils.helpers.xml.Xml__Element   import XML__Element
+
+class Xml__File(Type_Safe):
+    xml_data    : str                           # Raw XML content
+    root_element: XML__Element                  # Parsed root element
+    namespaces  : Dict[str, str]                # XML namespace mappings
+

osbot_utils/helpers/xml/Xml__File__Load.py

@@ -0,0 +1,88 @@
+from io                                     import StringIO
+from typing                                 import List, Union, Dict
+from xml.etree.ElementTree                  import iterparse, Element, fromstring, ParseError
+from osbot_utils.base_classes.Type_Safe     import Type_Safe
+from osbot_utils.helpers.xml.Xml__Attribute import Xml__Attribute
+from osbot_utils.helpers.xml.Xml__Element   import XML__Element
+from osbot_utils.helpers.xml.Xml__File      import Xml__File
+
+
+class Xml__File__Load(Type_Safe):
+
+    def load_from_string(self, xml_data: str) -> Xml__File:    # Create Xml__File from string
+        xml_file = Xml__File(xml_data=xml_data)
+        self.load_namespaces(xml_file)
+        self.parse_xml      (xml_file)
+        return xml_file
+
+    def load_namespaces(self, xml_file: Xml__File):           # Extract namespaces from XML
+        if not xml_file.xml_data:
+            raise ValueError("XML data cannot be empty")
+
+        for event, elem in iterparse(StringIO(xml_file.xml_data), events=("start-ns",)):
+            prefix, uri = elem
+            xml_file.namespaces[prefix] = uri
+
+    def parse_xml(self, xml_file: Xml__File):                 # Parse XML into type-safe structure
+        if not xml_file.xml_data:
+            raise ValueError("XML data cannot be empty")
+
+        try:
+            root       = fromstring(xml_file.xml_data)
+            namespaces = xml_file.namespaces
+            xml_file.root_element = self.convert_element(namespaces,root)
+        except ParseError as error:
+            raise ValueError(f"Invalid XML: {str(error)}")
+
+    def convert_element(self, namespaces: Dict[str,str], element: Element) -> XML__Element:
+        attributes = self.convert_attributes(element)
+        children: List[Union[str, XML__Element]] = []
+
+        tag             = element.tag
+        namespace        = ''
+        namespace_prefix = ''
+
+        if '}' in tag:
+            namespace, tag = tag.split('}', 1)          # Split namespace and tag
+            namespace = namespace[1:]                   # Remove the '{' prefix
+
+            for prefix, uri in namespaces.items(): # Find prefix for this namespace
+                if uri == namespace:
+                    namespace_prefix = prefix
+                    break
+
+        # Handle text content
+        if element.text and element.text.strip():
+            children.append(element.text.strip())
+
+        # Process child elements
+        for child in element:
+            child_element = self.convert_element(namespaces, child)
+            children.append(child_element)
+
+            if child.tail and child.tail.strip():
+                children.append(child.tail.strip())
+
+        return XML__Element(tag=tag,
+                          namespace=namespace,
+                          namespace_prefix=namespace_prefix,
+                          attributes=attributes,
+                          children=children)
+
+    def convert_attributes(self, element: Element) -> Dict[str, Xml__Attribute]:    # Convert element attributes
+        attributes = {}
+        for key, value in element.attrib.items():
+            if '}' in key:                                        # Handle namespaced attributes
+                namespace, name = key.split('}', 1)
+                namespace = namespace[1:]                         # Remove the '{' prefix
+            else:
+                namespace = ''
+                name = key
+
+            attribute = Xml__Attribute(
+                name=name,
+                value=value,
+                namespace=namespace
+            )
+            attributes[key] = attribute
+        return attributes

osbot_utils/helpers/xml/Xml__File__To_Dict.py

@@ -0,0 +1,41 @@
+from typing                                 import Dict, Any
+from osbot_utils.base_classes.Type_Safe     import Type_Safe
+from osbot_utils.helpers.xml.Xml__Element   import XML__Element
+from osbot_utils.helpers.xml.Xml__File      import Xml__File
+
+
+class Xml__File__To_Dict(Type_Safe):
+    def to_dict(self, xml_file: Xml__File) -> Dict[str, Any]:   # Convert Xml__File to dictionary
+        if not xml_file.root_element:
+            return {}
+        return self.element_to_dict(xml_file.root_element)
+
+    def element_to_dict(self, element: XML__Element) -> Dict[str, Any]:         # Convert XML__Element to dictionary
+        result = {}
+
+        for key, attr in element.attributes.items():                            # Convert attributes first
+            result[key] = attr.value
+
+
+        child_nodes: Dict[str, Any] = {}                                        # Process children and collect text content
+        text_content = []
+        for child in element.children:
+            if isinstance(child, str):
+                text_content.append(child)
+            else:
+                if child.tag in child_nodes:                     # Handle child elements
+                    if not isinstance(child_nodes[child.tag], list):
+                        child_nodes[child.tag] = [child_nodes[child.tag]]
+                    child_nodes[child.tag].append(self.element_to_dict(child))
+                else:
+                    child_nodes[child.tag] = self.element_to_dict(child)
+
+        if text_content:                                        # Handle text content
+            text_value = ' '.join(text_content)
+            if child_nodes or result:                           # If we have attributes or child nodes
+                result['#text'] = text_value                    # Add text as a special key
+            else:
+                return text_value                               # Return just the text if no attributes/children
+
+        result.update(child_nodes)                             # Merge child nodes into result
+        return result

osbot_utils/helpers/xml/Xml__File__To_Xml.py

@@ -0,0 +1,72 @@
+from typing                                 import Optional
+from xml.etree.ElementTree                  import Element, SubElement, tostring
+from xml.dom                                import minidom
+from osbot_utils.base_classes.Type_Safe     import Type_Safe
+from osbot_utils.helpers.xml.Xml__Element   import XML__Element
+from osbot_utils.helpers.xml.Xml__File      import Xml__File
+
+class Xml__File__To_Xml(Type_Safe):
+
+    def convert_to_xml(self, xml_file: Xml__File, pretty_print: bool = True) -> str:
+        if not xml_file.root_element:
+            raise ValueError("XML file must have a root element")
+
+        # Create XML element tree
+        root = self.create_element(xml_file.root_element, xml_file.namespaces)
+
+        # Add all namespace declarations to root element
+        for prefix, uri in xml_file.namespaces.items():
+            if prefix == '':
+                root.set('xmlns', uri)
+            else:
+                root.set(f'xmlns:{prefix}', uri)
+
+        # Convert to string
+        xml_string = tostring(root, encoding='unicode', method='xml')
+
+        # Pretty print if requested
+        if pretty_print:
+            return self.pretty_print(xml_string)
+        return xml_string
+
+    def create_element(self, xml_element: XML__Element, namespaces: Optional[dict] = None, parent: Optional[Element] = None) -> Element:
+        # Create tag with namespace if applicable
+        tag = xml_element.tag
+        if xml_element.namespace_prefix:
+            tag = f"{xml_element.namespace_prefix}:{tag}"
+        # Don't add namespace URI for default namespace - let it be inherited
+
+        # Create new element or sub-element
+        if parent is not None:
+            element = SubElement(parent, tag)
+        else:
+            element = Element(tag)
+
+        # Add attributes including namespace declarations
+        for attr_key, attr in xml_element.attributes.items():
+            if attr.namespace:
+                attr_name = f"{{{attr.namespace}}}{attr.name}"
+            else:
+                attr_name = attr.name
+            element.set(attr_name, attr.value)
+
+        # Process children
+        text_parts = []
+        for child in xml_element.children:
+            if isinstance(child, str):
+                text_parts.append(child)
+            elif isinstance(child, XML__Element):
+                self.create_element(child, namespaces, element)
+
+        # Set text content if any
+        if text_parts:
+            element.text = ''.join(text_parts)
+
+        return element
+
+    def pretty_print(self, xml_string: str) -> str:
+        """Format XML string with proper indentation."""
+        parsed = minidom.parseString(xml_string)
+        pretty_xml = parsed.toprettyxml(indent='  ').rstrip() + '\n'
+        # Remove empty lines (common issue with toprettyxml)
+        return '\n'.join(line for line in pretty_xml.split('\n') if line.strip())

osbot_utils/helpers/xml/rss/RSS__Channel.py

@@ -0,0 +1,17 @@
+from typing                                     import Any, Dict, List
+from osbot_utils.base_classes.Type_Safe         import Type_Safe
+from osbot_utils.helpers.xml.rss.RSS__Image     import RSS__Image
+from osbot_utils.helpers.xml.rss.RSS__Item      import RSS__Item
+
+
+class RSS__Channel(Type_Safe):
+    description     : str
+    extensions      : Dict[str, Any]
+    image           : RSS__Image         = None
+    items           : List[RSS__Item]
+    language        : str
+    last_build_date : str
+    link            : str
+    title           : str
+    update_frequency: str
+    update_period   : str

osbot_utils/helpers/xml/rss/RSS__Enclosure.py

@@ -0,0 +1,7 @@
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+
+
+class RSS__Enclosure(Type_Safe):
+    url    : str
+    type   : str
+    length : int

osbot_utils/helpers/xml/rss/RSS__Feed.py

@@ -0,0 +1,11 @@
+from typing                                     import Dict, Any
+from osbot_utils.base_classes.Type_Safe         import Type_Safe
+from osbot_utils.helpers.xml.rss.RSS__Channel   import RSS__Channel
+
+DEFAULT__RSS_FEED__VERSION = "2.0"
+
+class RSS__Feed(Type_Safe):
+    version    : str           = DEFAULT__RSS_FEED__VERSION
+    channel    : RSS__Channel  = None
+    namespaces : Dict[str, str]
+    extensions : Dict[str, Any]

osbot_utils/helpers/xml/rss/RSS__Feed__Parser.py

@@ -0,0 +1,93 @@
+from typing                                     import Dict, Any
+from osbot_utils.helpers.Guid                   import Guid
+from osbot_utils.helpers.xml.rss.RSS__Channel   import RSS__Channel
+from osbot_utils.helpers.xml.rss.RSS__Feed      import RSS__Feed
+from osbot_utils.helpers.xml.rss.RSS__Image     import RSS__Image
+from osbot_utils.helpers.xml.rss.RSS__Item      import RSS__Item
+
+
+class RSS__Feed__Parser:
+
+    def from_dict(self, data: Dict[str, Any]) -> RSS__Feed: # Convert a dictionary (from XML) into an RSS__Feed object
+        if 'channel' not in data:
+            raise ValueError("Invalid RSS feed: no channel element found")
+
+        channel_data = data['channel']
+        rss_items    = []
+        items        = channel_data.get('item', [])                                 # get raw items data
+        if type(items) is not list:                                                 # handle case when only one item is present
+            items = [items]                                                         # by converting it to a list
+        for item_data in items:                                                     # Process items
+
+            title       = self.element_text(item_data.get('title'      ))
+            link        = self.element_text(item_data.get('link'       ))
+            description = self.element_text(item_data.get('description'))
+            guid        = self.extract_guid(item_data.get('guid'       ))
+            pubDate     = self.element_text(item_data.get('pubDate'    ))
+            creator     = self.element_text(item_data.get('creator'    ))
+            rss_item = RSS__Item(title       = title                    ,
+                                 link        = link                     ,
+                                 description = description              ,
+                                 guid        = guid                     ,
+                                 pubDate     = pubDate                  ,
+                                 creator     = creator                  ,
+                                 categories  = item_data.get('category'     , []),
+                                 content     = item_data.get('content'      , {}),
+                                 thumbnail   = item_data.get('thumbnail'    , {}))
+
+
+            known_fields = {'title', 'link', 'description', 'guid', 'pubDate',          # Move non-standard elements to extensions
+                          'creator', 'category', 'content', 'thumbnail'}
+            rss_item.extensions = {k: v for k, v in item_data.items()
+                                   if k not in known_fields}
+            rss_items.append(rss_item)
+
+        # Create channel
+        link = self.element_text(channel_data.get('link'))
+        channel = RSS__Channel( title            = channel_data.get('title'          , ''),
+                                link             = link                                   ,
+                                description      = channel_data.get('description'    , ''),
+                                language         = channel_data.get('language'       , ''),
+                                last_build_date  = channel_data.get('lastBuildDate'      ),
+                                items            = rss_items                              ,
+                                update_frequency = channel_data.get('updateFrequency', ''),
+                                update_period    = channel_data.get('updatePeriod'   , ''))
+
+
+        # Process channel image if present
+        if 'image' in channel_data:
+            img_data = channel_data['image']
+            channel.image = RSS__Image( url     = img_data.get('url'       , '' ),
+                                        title   = img_data.get('title'     , '' ),
+                                        link    = img_data.get('link'      , '' ),
+                                        width   = int(img_data.get('width' , 0 )),
+                                        height  = int(img_data.get('height', 0 )))
+
+        known_channel_fields = {'title', 'link', 'description', 'language',         # Move non-standard channel elements to extensions
+                               'lastBuildDate', 'image', 'item', 'updateFrequency', 'updatePeriod'}
+        channel.extensions = {k: v for k, v in channel_data.items()
+                            if k not in known_channel_fields}
+
+        rss_feed = RSS__Feed(channel = channel)
+        return rss_feed
+
+    def extract_guid(self, target):
+        return Guid(self.extract_text(target))
+
+    def element_text(self, target):
+        if isinstance(target, list):
+            for item in target:
+                value = self.extract_text(item)
+                if value:
+                    return value
+        value = self.extract_text(target)
+        return value or f'{target}'
+
+    def extract_text(self, target):
+        if not target:
+            return ''
+        if isinstance(target, str):
+            return target
+        if isinstance(target, dict):
+            return target.get('#text', '')
+        return ''

osbot_utils/helpers/xml/rss/RSS__Image.py

@@ -0,0 +1,8 @@
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+
+class RSS__Image(Type_Safe):
+    url    : str
+    title  : str
+    link   : str
+    width  : int
+    height : int

osbot_utils/helpers/xml/rss/RSS__Item.py

@@ -0,0 +1,17 @@
+from typing                                         import Dict, List, Any
+from osbot_utils.base_classes.Type_Safe             import Type_Safe
+from osbot_utils.helpers.Guid                       import Guid
+from osbot_utils.helpers.xml.rss.RSS__Enclosure     import RSS__Enclosure
+
+class RSS__Item(Type_Safe):
+    title       : str
+    link        : str
+    description : str
+    guid        : Guid
+    pubDate     : str
+    creator     : str
+    categories  : List[str]
+    enclosure   : RSS__Enclosure = None
+    content     : Dict[str, Any]
+    thumbnail   : Dict[str, Any]
+    extensions  : Dict[str, Any]

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/version

@@ -1 +1 @@
-v1.88.0
+v1.90.0

{osbot_utils-1.88.0.dist-info → osbot_utils-1.90.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.88.0
+Version: 1.90.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.90.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.dist-info → osbot_utils-1.90.0.dist-info}/RECORD

@@ -2,8 +2,10 @@ osbot_utils/__init__.py,sha256=DdJDmQc9zbQUlPVyTJOww6Ixrn9n4bD3ami5ItQfzJI,16
 osbot_utils/base_classes/Cache_Pickle.py,sha256=kPCwrgUbf_dEdxUz7vW1GuvIPwlNXxuRhb-H3AbSpII,5884
 osbot_utils/base_classes/Kwargs_To_Disk.py,sha256=HHoy05NC_w35WcT-OnSKoSIV_cLqaU9rdjH0_KNTM0E,1096
 osbot_utils/base_classes/Kwargs_To_Self.py,sha256=weFNsBfBNV9W_qBkN-IdBD4yYcJV_zgTxBRO-ZlcPS4,141
-osbot_utils/base_classes/Type_Safe.py,sha256=VeNkr6BD9iA9LyQ2FiduHIMM8nS0iaALpwYC2Y-KWy4,23445
-osbot_utils/base_classes/Type_Safe__List.py,sha256=iWyoc2xjHkTJrZTVnPse9Rljte2tF67oNq8yA7jnAhY,5996
+osbot_utils/base_classes/Type_Safe.py,sha256=oEwxNPa1pcq6ccJUyWPUuuMXK6CRzVIzwQNL2lcc6E4,24663
+osbot_utils/base_classes/Type_Safe__Base.py,sha256=CFPYe8_i5vvTLyc7s8CXbY4n_dY6sqVfBY8w9Vo77ZA,5468
+osbot_utils/base_classes/Type_Safe__Dict.py,sha256=sfZcukhXUd9TS0PQpAk-gGLfZUJSC6BtMh6jF4Fn8Jw,1107
+osbot_utils/base_classes/Type_Safe__List.py,sha256=pXDzJJttpEQQ9oTdsw7BykMB4VIX2rZzi1ZrnCzMZ8M,650
 osbot_utils/base_classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/context_managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/context_managers/async_invoke.py,sha256=-ja3K8orLy8Of54CIYSK-zn443pOIDY2hnFBjVELrXc,829
@@ -267,6 +269,19 @@ osbot_utils/helpers/trace/Trace_Call__Stats.py,sha256=gmiotIrOXe2ssxodzQQ56t8eGT
 osbot_utils/helpers/trace/Trace_Call__View_Model.py,sha256=a40nn6agCEMd2ecsJ93n8vXij0omh0D69QilqwmN_ao,4545
 osbot_utils/helpers/trace/Trace_Files.py,sha256=SNpAmuBlSUS9NyVocgZ5vevzqVaIqoh622yZge3a53A,978
 osbot_utils/helpers/trace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osbot_utils/helpers/xml/Xml__Attribute.py,sha256=r29x8ehRug27KuHQKQEGl6Thz_MNaNHy6X3cPRgH4ho,148
+osbot_utils/helpers/xml/Xml__Element.py,sha256=J0hMaJPIBNmZf4wo0xrtZBZd5vWie5FoX9XqtAXQToM,871
+osbot_utils/helpers/xml/Xml__File.py,sha256=c3axXx07rIoK5tGzpLwH-X1B7nusSe1-SZAxJNZJ0KI,420
+osbot_utils/helpers/xml/Xml__File__Load.py,sha256=iAH21HjrqFoZlU5-Kg2RE53RBdNs0mDaASETUTnbhRo,3625
+osbot_utils/helpers/xml/Xml__File__To_Dict.py,sha256=1KGswrpMpUPu4JDYUbkP8GTOQfHGcGONnDYsi-_aqv0,2061
+osbot_utils/helpers/xml/Xml__File__To_Xml.py,sha256=HvUbYOfLz6i160_to90dP3b1uy3Z85nnj7qaGN8LEBI,2884
+osbot_utils/helpers/xml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osbot_utils/helpers/xml/rss/RSS__Channel.py,sha256=HPLsGRNIaPh0_8GYE2a53bSV5Bb4E6j6tKGuy4bxg4Y,605
+osbot_utils/helpers/xml/rss/RSS__Enclosure.py,sha256=f75U7nXXJ7hLs2zPDui0WsFAmMJaeaverjlxD4M-Otg,142
+osbot_utils/helpers/xml/rss/RSS__Feed.py,sha256=lhFoeBMWdH1Dp8QnagCGj9bfZHKmB_HkE56hPVZNaM0,425
+osbot_utils/helpers/xml/rss/RSS__Feed__Parser.py,sha256=qG4FbUexMmU6_pTgcxDBmBeZvh9d1dmFZGzQOwVlggk,5088
+osbot_utils/helpers/xml/rss/RSS__Image.py,sha256=4uI0jd17pqb8FJ8HQcERXvn3WjGbiOVI8u1tv-IN59U,171
+osbot_utils/helpers/xml/rss/RSS__Item.py,sha256=y-QI2WBfd9FEsVWc_eNirvZUUslpb2z27hxcm-RVHJQ,611
 osbot_utils/testing/Catch.py,sha256=HdNoKnrPBjvVj87XYN-Wa1zpo5z3oByURT6TKbd5QpQ,2229
 osbot_utils/testing/Custom_Handler_For_Http_Tests.py,sha256=LKscFEcuwTQQ9xl4q71PR5FA8U-q8OtfTkCJoIgQIoQ,5358
 osbot_utils/testing/Duration.py,sha256=iBrczAuw6j3jXtG7ZPraT0PXbCILEcCplJbqei96deA,2217
@@ -303,7 +318,7 @@ osbot_utils/utils/Json.py,sha256=0DZGlCU7Nqte5n0r7ctPXFybqA5MRfSrTz5zuK_6UFk,709
 osbot_utils/utils/Json_Cache.py,sha256=mLPkkDZN-3ZVJiDvV1KBJXILtKkTZ4OepzOsDoBPhWg,2006
 osbot_utils/utils/Lists.py,sha256=tPz5x5s3sRO97WZ_nsxREBPC5cwaHrhgaYBhsrffTT8,5599
 osbot_utils/utils/Misc.py,sha256=H_xexJgiTxB3jDeDiW8efGQbO0Zuy8MM0iQ7qXC92JI,17363
-osbot_utils/utils/Objects.py,sha256=iuNNp_u9aOiHtAXwkSo-8FikXWcqZczaZqNwHKKQEcM,19617
+osbot_utils/utils/Objects.py,sha256=qzdwfQZMyI-ySlOhuUM6z2M4cW9eZDXpUeTIzgYwlS4,19977
 osbot_utils/utils/Png.py,sha256=V1juGp6wkpPigMJ8HcxrPDIP4bSwu51oNkLI8YqP76Y,1172
 osbot_utils/utils/Process.py,sha256=lr3CTiEkN3EiBx3ZmzYmTKlQoPdkgZBRjPulMxG-zdo,2357
 osbot_utils/utils/Python_Logger.py,sha256=tx8N6wRKL3RDHboDRKZn8SirSJdSAE9cACyJkxrThZ8,12792
@@ -315,8 +330,8 @@ osbot_utils/utils/Toml.py,sha256=Rxl8gx7mni5CvBAK-Ai02EKw-GwtJdd3yeHT2kMloik,166
 osbot_utils/utils/Version.py,sha256=Ww6ChwTxqp1QAcxOnztkTicShlcx6fbNsWX5xausHrg,422
 osbot_utils/utils/Zip.py,sha256=pR6sKliUY0KZXmqNzKY2frfW-YVQEVbLKiyqQX_lc-8,14052
 osbot_utils/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/version,sha256=D0MVxZOCQlRSLSl_5l6QLAIYIlH9b7vBFCZn_V3Z2WY,8
-osbot_utils-1.88.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-1.88.0.dist-info/METADATA,sha256=KAjZ52Wxr8Kq06sTXHWU8RzvgSGltoSiT7BWLDPKTRg,1317
-osbot_utils-1.88.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-osbot_utils-1.88.0.dist-info/RECORD,,
+osbot_utils/version,sha256=BspJJ07wPk_cd1Tk06A-p8nFKYNDb_kD0KykvCZJpMc,8
+osbot_utils-1.90.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-1.90.0.dist-info/METADATA,sha256=0FRdshsrS_RyXSve5jzGaHU5JXGt9_X6gDE8-N9frH0,1317
+osbot_utils-1.90.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+osbot_utils-1.90.0.dist-info/RECORD,,