Made changes in the element_to_dict function and changed function names to be more descriptive

Author: mqnifestkelvin

src/modelspec/base_types.py

@@ -170,15 +170,15 @@ def from_bson(cls, bson_str: str) -> "Base":
     def from_xml(cls, xml_str: str) -> "Base":
         """Instantiate a Base object from an XML string"""
         from modelspec.utils import (
-            element_to_dict,
-            handle_id,
-            convert_values,
+            elementtree_element_to_dict,
+            handle_xml_dict_id,
+            convert_xml_dict_values,
             process_xml_namespace,
         )
         import re
 
         # When the to_xml() method is used it messes up the string therefore,
-        # it is necessary to convert it into an elementree object the decode into a string.
+        # it is necessary to convert it into an elementree object then decode into a string.
         xml_string_a = ET.fromstring(xml_str)
         xml_string_b = ET.tostring(xml_string_a).decode()
 
@@ -192,15 +192,15 @@ def from_xml(cls, xml_str: str) -> "Base":
         # be removed when converting to a dict, the process_xml_namespaes function does just that.
         removed_namespaces = process_xml_namespace(cleaned_xml)
 
-        # process_xml_namespace function returns an elementtree object which can be directly worked upon by the element_to_dict
+        # process_xml_namespace function returns an elementtree object which can be directly worked upon by the elementtree_element_to_dict
         # function, this returns a python dictionary
-        data_dict = element_to_dict(removed_namespaces)
+        data_dict = elementtree_element_to_dict(removed_namespaces)
 
         # This strips every instance of 'id' from the resulting dictionary structure
-        removed_id = handle_id(data_dict)
+        removed_id = handle_xml_dict_id(data_dict)
 
         # XML conversions do not returns exact values, instead all values are returned as a string, this reassigns their actual values
-        converted_to_actual_val = convert_values(removed_id)
+        converted_to_actual_val = convert_xml_dict_values(removed_id)
 
         return cls.from_dict(converted_to_actual_val)
 
@@ -403,9 +403,9 @@ def from_xml_file(cls, filename: str) -> "Base":
             A modelspec Base for this XML.
         """
         from modelspec.utils import (
-            element_to_dict,
-            handle_id,
-            convert_values,
+            elementtree_element_to_dict,
+            handle_xml_dict_id,
+            convert_xml_dict_values,
             process_xml_namespace,
         )
         import re
@@ -423,17 +423,17 @@ def from_xml_file(cls, filename: str) -> "Base":
         cleaned_xml = re.sub(ns_prefix_pattern, "", xml_string).strip()
 
         # Removes xmlns, xmlns:xsi and xsi:schemaLocation from the xml structure for conversion
-        # it passes an element tree object to the element_to_dict function
+        # it passes an element tree object to the elementtree_element_to_dict function
         removed_namespaces = process_xml_namespace(cleaned_xml)
 
         # Converts the resulting xml stripped of xmlns, xmlns:xsi and xsi:schemaLocation into a dict
-        data_dict = element_to_dict(removed_namespaces)
+        data_dict = elementtree_element_to_dict(removed_namespaces)
 
         # Removes every key having 'id' and replaces it with it's value
-        removed_id = handle_id(data_dict)
+        removed_id = handle_xml_dict_id(data_dict)
 
         # Values are returned as strings after conversion, this corrects them to their actual values
-        converted_to_actual_val = convert_values(removed_id)
+        converted_to_actual_val = convert_xml_dict_values(removed_id)
         return cls.from_dict(converted_to_actual_val)
 
     def get_child(self, id: str, type_: str) -> Any:

src/modelspec/utils.py

@@ -82,22 +82,22 @@ def load_xml(filename: str):
     cleaned_xml = re.sub(ns_prefix_pattern, "", xml_string).strip()
 
     # Removes xmlns, xmlns:xsi and xsi:schemaLocation from the xml structure for conversion
-    # it passes an element tree object to the element_to_dict function
+    # it passes an element tree object to the elementtree_element_to_dict function
     removed_namespaces = process_xml_namespace(cleaned_xml)
 
     # Converts the resulting xml stripped of xmlns, xmlns:xsi and xsi:schemaLocation into a dict
-    data = element_to_dict(removed_namespaces)
+    data = elementtree_element_to_dict(removed_namespaces)
 
     # Removes every key having 'id' and replaces it with it's value
-    removed_id = handle_id(data)
+    removed_id = handle_xml_dict_id(data)
 
     # Values are returned as strings after conversion, this corrects them to their actual values
-    converted_to_actual_val = convert_values(removed_id)
+    converted_to_actual_val = convert_xml_dict_values(removed_id)
 
-    return convert_values(converted_to_actual_val)
+    return convert_xml_dict_values(converted_to_actual_val)
 
 
-def element_to_dict(element):
+def elementtree_element_to_dict(element):
     """
     This convert an ElementTree element to a dictionary.
 
@@ -115,7 +115,7 @@ def element_to_dict(element):
     children_by_tag = {}
     for child_element in element:
         child_key = child_element.tag + "s"
-        child_value = element_to_dict(child_element)
+        child_value = elementtree_element_to_dict(child_element)
 
         # Check if the child element has an 'id' attribute
         if "id" in child_element.attrib:
@@ -148,21 +148,21 @@ def process_xml_namespace(xml_string):
     return root
 
 
-def handle_id(dictionary):
+def handle_xml_dict_id(dictionary):
     if isinstance(dictionary, dict):
         if "id" in dictionary:
             nested_dict = {dictionary["id"]: dictionary.copy()}
             del nested_dict[dictionary["id"]]["id"]
-            return {k: handle_id(v) for k, v in nested_dict.items()}
+            return {k: handle_xml_dict_id(v) for k, v in nested_dict.items()}
         else:
-            return {k: handle_id(v) for k, v in dictionary.items()}
+            return {k: handle_xml_dict_id(v) for k, v in dictionary.items()}
     elif isinstance(dictionary, list):
-        return [handle_id(item) for item in dictionary]
+        return [handle_xml_dict_id(item) for item in dictionary]
     else:
         return dictionary
 
 
-def convert_values(value):
+def convert_xml_dict_values(value):
     """
     This recursively converts values to their actual types.
 
@@ -186,9 +186,9 @@ def convert_values(value):
         elif value.lower() == "none":
             return None
     elif isinstance(value, dict):
-        return {key: convert_values(val) for key, val in value.items()}
+        return {key: convert_xml_dict_values(val) for key, val in value.items()}
     elif isinstance(value, list):
-        return [convert_values(item) for item in value]
+        return [convert_xml_dict_values(item) for item in value]
 
     return value
 
@@ -246,47 +246,36 @@ def build_xml_element(data, parent=None):
     Returns:
         Parent
     """
-
     if parent is None:
         parent = ET.Element(data.__class__.__name__)
 
     attrs = attr.fields(data.__class__)
-    id_attribute_value = None  # Store id attribute value to be set after other attributes
     for aattr in attrs:
-        if aattr.name == 'id':
-            id_attribute_value = data.__getattribute__(aattr.name)
-        elif isinstance(aattr.default, attr.Factory):
+        if isinstance(aattr.default, attr.Factory):
             children = data.__getattribute__(aattr.name)
             if not isinstance(children, (list, tuple)):
                 children = [children]
 
             for child in children:
                 child_element = build_xml_element(child)
                 parent.append(child_element)
-        
-        # Filters name space and schemaLoacation attributes, only allows non name space attributes to added as attributes
-        elif not any(
-            hasattr(data, attr_name)
-            for attr_name in ["xmlns", "xmlns_url", "xmlns_loc", "xmln_loc_2"]
-        ):
+
+        # Filters name space and schemaLoacation attributes, only allows non name space attributes to be added as attributes
+        elif aattr.name not in ["xmlns", "xmlns_url", "xmlns_loc", "xmln_loc_2"]:
             attribute_name = aattr.name
             attribute_value = data.__getattribute__(aattr.name)
             parent.set(attribute_name, str(attribute_value))
-    
+
     # This defines the various namespaces and schemaLocation of the generated xml
     if hasattr(data, "xmlns"):
         parent.set("xmlns", data.xmlns)
     if hasattr(data, "xmlns_url"):
         parent.set("xmlns:xsi", data.xmlns_url)
     if hasattr(data, "xmlns_loc"):
         parent.set("xsi:schemaLocation", str(data.xmlns_loc + " " + data.xmln_loc_2))
-
-    # Set the id attribute after processing all other attributes
-    if id_attribute_value is not None:
-        parent.set("id", str(id_attribute_value))
-
     return parent
 
+
 def ascii_encode_dict(data):
     ascii_encode = (
         lambda x: x.encode("ascii")