Fix adding default and fixed values for attributes and elements

  - Default an fixed values applied on omitted attributes and
    empty elements
  - Add xsd_element to element nodes and augment attributes with
    missing defaults in lazy mode.
  - Add test extracted from the issue and with another element for
    testing default value of attributes

Author: brunato

elementpath/compare.py

@@ -83,7 +83,7 @@ def etree_deep_equal(e1: ElementProtocol, e2: ElementProtocol) -> bool:
                     return False
                 elif isinstance(value1, etree_node_types):
                     assert isinstance(value2, etree_node_types)
-                    if not etree_deep_equal(value1.obj, value2.obj):
+                    if not etree_deep_equal(value1.value, value2.value):
                         return False
                 elif isinstance(value1, EtreeDocumentNode):
                     assert isinstance(value2, EtreeDocumentNode)
@@ -94,14 +94,14 @@ def etree_deep_equal(e1: ElementProtocol, e2: ElementProtocol) -> bool:
                             return False
                         elif isinstance(child1, etree_node_types):
                             assert isinstance(child2, etree_node_types)
-                            if not etree_deep_equal(child1.obj, child2.obj):
+                            if not etree_deep_equal(child1.value, child2.value):
                                 return False
                         elif isinstance(child1, TextNode):
                             assert isinstance(child2, TextNode)
-                            if cm.ne(child1.obj, child2.obj):
+                            if cm.ne(child1.value, child2.value):
                                 return False
 
-                elif cm.ne(value1.obj, value2.obj):
+                elif cm.ne(value1.value, value2.value):
                     return False
                 elif isinstance(value1, TextAttributeNode):
                     if cm.ne(value1.name, value2.name):
@@ -257,7 +257,7 @@ def etree_deep_compare(e1: ElementProtocol, e2: ElementProtocol) -> int:
                     raise xpath_error('XPTY0004', msg, token=token)
                 elif isinstance(value1, etree_node_types):
                     assert isinstance(value2, etree_node_types)
-                    result = etree_deep_compare(value1.obj, value2.obj)
+                    result = etree_deep_compare(value1.value, value2.value)
                     if result:
                         return result
                 elif isinstance(value1, EtreeDocumentNode):
@@ -272,19 +272,19 @@ def etree_deep_compare(e1: ElementProtocol, e2: ElementProtocol) -> int:
                             raise xpath_error('XPTY0004', msg, token=token)
                         elif isinstance(child1, etree_node_types):
                             assert isinstance(child2, etree_node_types)
-                            result = etree_deep_compare(child1.obj, child2.obj)
+                            result = etree_deep_compare(child1.value, child2.value)
                             if result:
                                 return result
                         elif isinstance(child1, TextNode):
                             assert isinstance(child2, TextNode)
                             result = cm.strcoll(
-                                child1.obj.strip(), child2.obj.strip()
+                                child1.value.strip(), child2.value.strip()
                             )
                             if result:
                                 return result
                 elif isinstance(value1, TextNode):
                     assert isinstance(value2, TextNode)
-                    result = cm.strcoll(value1.obj, value2.obj)
+                    result = cm.strcoll(value1.value, value2.value)
                     if result:
                         return result
                 elif isinstance(value1, TextAttributeNode):

elementpath/extras/pathnodes.py

@@ -24,7 +24,7 @@
 
 class PathElementNode(ElementNode):
     name: str
-    obj: Path
+    value: Path
     xsd_element: Optional[XsdElementProtocol]
 
     __slots__ = ('stat',)
@@ -53,7 +53,7 @@ def __init__(self,
             self.parent = parent
 
         self.name = path.name
-        self.obj = path
+        self.value = path
         self.stat = path.stat()
         self.position = self.stat.st_ino
         self.children = []
@@ -63,9 +63,9 @@ def __init__(self,
 
     @property
     def content(self) -> Path:
-        return self.obj
+        return self.value
 
-    elem = value = content
+    elem = content
 
     @property
     def attributes(self) -> list[AttributeNode]:
@@ -101,10 +101,10 @@ def path(self) -> str:
 
     @property
     def string_value(self) -> str:
-        if self.obj.is_dir():
+        if self.value.is_dir():
             return ''
-        if self.obj.is_file():
-            return self.obj.read_text()
+        if self.value.is_file():
+            return self.value.read_text()
         else:
             return ''
 
@@ -125,12 +125,12 @@ def match_name(self, name: str, default_namespace: Optional[str] = None) -> bool
             return self.name == f'{{{default_namespace}}}{name}'
 
     def get_document_node(self, replace: bool = True, as_parent: bool = True) -> 'DocumentNode':
-        return PathDocumentNode(Path(self.obj.absolute().root))
+        return PathDocumentNode(Path(self.value.absolute().root))
 
     def __iter__(self) -> Iterator[ChildNodeType]:
         if not self.children:
-            if self.obj.is_dir():
-                for path in self.obj.iterdir():
+            if self.value.is_dir():
+                for path in self.value.iterdir():
                     if path in self.tree.elements:
                         self.children.append(self.tree.elements[path])
                     else:
@@ -150,7 +150,7 @@ def iter_descendants(self, with_self: bool = True) -> Iterator[ChildNodeType]:
 
 
 class PathDocumentNode(DocumentNode):
-    obj: Path
+    value: Path
 
     __slots__ = ('stat',)
 
@@ -159,7 +159,7 @@ def __init__(self, document: Path, uri: Optional[str] = None) -> None:
         if not document.is_dir() or len(document.parts) > 1 or not document.is_absolute():
             raise ValueError(f'{document} must be a root directory')
 
-        self.obj = document
+        self.value = document
         self.name = None
         self.parent = None
         self.position = document.stat().st_ino
@@ -168,15 +168,15 @@ def __init__(self, document: Path, uri: Optional[str] = None) -> None:
 
     @property
     def document(self) -> Path:
-        return self.obj
+        return self.value
 
     @property
     def string_value(self) -> str:
-        return self.obj.read_text()
+        return self.value.read_text()
 
     def __iter__(self) -> Iterator[ChildNodeType]:
         if not self.children:
-            for path in self.obj.iterdir():
+            for path in self.value.iterdir():
                 if path in self.tree.elements:
                     self.children.append(self.tree.elements[path])
                 else:
@@ -187,7 +187,7 @@ def __iter__(self) -> Iterator[ChildNodeType]:
 
 class IntAttributeNode(AttributeNode):
     name: str
-    obj: int
+    value: int
     parent: Optional['PathElementNode']
 
     __slots__ = ()
@@ -198,22 +198,18 @@ def __init__(self,
                  parent: Optional['PathElementNode'] = None) -> None:
 
         self.name = name
-        self.obj = value
+        self.value = value
         self.parent = parent
         self.position = parent.position if parent is not None else 1
         self.xsd_type = None
 
-    @property
-    def value(self) -> int:
-        return self.obj
-
     @property
     def string_value(self) -> str:
-        return str(self.obj)
+        return str(self.value)
 
     @property
     def iter_typed_values(self) -> Iterator[AtomicType]:
-        yield self.obj
+        yield self.value
 
     @property
     def type_name(self) -> Optional[str]:
@@ -224,12 +220,12 @@ class ModeAttributeNode(IntAttributeNode):
 
     @property
     def string_value(self) -> str:
-        return oct(self.obj)
+        return oct(self.value)
 
 
 class DatetimeAttributeNode(AttributeNode):
     name: str
-    obj: datetime
+    value: datetime
     parent: Optional['PathElementNode']
 
     __slots__ = ()
@@ -240,22 +236,18 @@ def __init__(self,
                  parent: Optional['PathElementNode'] = None) -> None:
 
         self.name = name
-        self.obj = value
+        self.value = value
         self.parent = parent
         self.position = parent.position if parent is not None else 1
         self.xsd_type = None
 
-    @property
-    def value(self) -> datetime:
-        return self.obj
-
     @property
     def string_value(self) -> str:
-        return str(self.obj)
+        return str(self.value)
 
     @property
     def iter_typed_values(self) -> Iterator[AtomicType]:
-        yield DateTime.fromdatetime(self.obj)
+        yield DateTime.fromdatetime(self.value)
 
     @property
     def type_name(self) -> Optional[str]:

elementpath/schema_proxy.py

@@ -143,23 +143,47 @@ def get_type(self, qname: str) -> Optional[XsdTypeProtocol]:
         """
         return self._schema.maps.types.get(qname)
 
-    def get_attribute(self, qname: str) -> Optional[XsdAttributeProtocol]:
+    def get_attribute(self, qname: str, parent_type: Optional[XsdTypeProtocol] = None) \
+            -> Optional[XsdAttributeProtocol]:
         """
         Get the XSD global attribute from the schema's scope.
 
         :param qname: the fully qualified name of the attribute to retrieve.
+        :param parent_type: an optional XSD type that represents the scope where matching \
+        the attribute name. If not provided, the scope is assumed to be the global scope.
         :returns: an object that represents an XSD type or `None`.
         """
-        return self._schema.maps.attributes.get(qname)
+        if parent_type is None:
+            return self._schema.maps.attributes.get(qname)
+        elif hasattr(parent_type, 'attributes'):
+            attributes = cast(XsdAttributeGroupProtocol, parent_type.attributes)
+            if qname in attributes:
+                return attributes[qname]
+            elif None in attributes and attributes[None].is_matching(qname):
+                return self._schema.maps.attributes[qname]
+        return None
 
-    def get_element(self, qname: str) -> Optional[XsdElementProtocol]:
+    def get_element(self, qname: str, parent_type: Optional[XsdTypeProtocol] = None) \
+            -> Optional[XsdElementProtocol]:
         """
         Get the XSD global element from the schema's scope.
 
-        :param qname: the fully qualified name of the element to retrieve.
+        :param qname: the fully qualified name of the attribute to retrieve.
+        :param parent_type: an optional XSD type that represents the scope where matching \
+        the child element name. If `None` or not provided the scope is the schema.
         :returns: an object that represents an XSD type or `None`.
         """
-        return self._schema.maps.elements.get(qname)
+        if parent_type is None:
+            return self._schema.maps.elements.get(qname)
+        elif (content := parent_type.model_group) is not None:
+            for xsd_element in content.iter_elements():
+                if xsd_element.is_matching(qname):
+                    if xsd_element.name == qname:
+                        return xsd_element
+                    else:
+                        # a wildcard or a substitute
+                        return self._schema.maps.elements.get(qname)
+        return None
 
     def get_substitution_group(self, qname: str) -> Optional[set[XsdElementProtocol]]:
         """

elementpath/serialization.py

@@ -139,7 +139,7 @@ def get_serialization_params(params: Union[None, ElementNode, XPathMap] = None,
                 kwargs[key] = value
 
     elif isinstance(params, ElementNode):
-        root = cast(Union[EtreeElementProtocol, LxmlElementProtocol], params.obj)
+        root = cast(Union[EtreeElementProtocol, LxmlElementProtocol], params.value)
         if root.tag != SERIALIZATION_PARAMS:
             msg = 'output:serialization-parameters tag expected'
             raise xpath_error('XPTY0004', msg, token)
@@ -293,14 +293,14 @@ def serialize_to_xml(elements: Iterable[Any],
     for item in iter_normalized(elements, item_separator):
         if isinstance(item, ElementNode):
             assert isinstance(item, EtreeElementNode)
-            elem = item.obj
+            elem = item.value
         elif isinstance(item, (AttributeNode, NamespaceNode)):
             raise xpath_error('SENR0001', token=token)
         elif isinstance(item, TextNode):
             if item.parent is not None and item.parent.name in cdata_section:
-                chunks.append(f'<![CDATA[{item.obj}]]>')
+                chunks.append(f'<![CDATA[{item.value}]]>')
             else:
-                chunks.append(item.obj)
+                chunks.append(item.value)
             continue
         elif not isinstance(item, str):
             raise xpath_error('SENR0001', token=token)
@@ -352,7 +352,7 @@ def default(self, obj: Any) -> Any:
                     return ''.join(self.default(child) for child in obj)
                 elif isinstance(obj, ElementNode):
                     assert isinstance(obj, EtreeElementNode)
-                    elem = obj.obj
+                    elem = obj.value
                     assert etree_module is not None
 
                     try:
@@ -368,7 +368,7 @@ def default(self, obj: Any) -> Any:
                 elif isinstance(obj, (AttributeNode, NamespaceNode)):
                     return f'{obj.name}="{obj.string_value}"'
                 elif isinstance(obj, TextNode):
-                    return obj.obj
+                    return obj.value
                 elif isinstance(obj, CommentNode):
                     return f'<!--{obj.string_value}-->'
                 else:

elementpath/tree_builders.py

@@ -56,7 +56,7 @@ def get_node_tree(root: RootArgType,
                 return root.getroot()
         elif fragment is False and \
                 isinstance(root, ElementNode) and \
-                is_etree_element_instance(root.obj):
+                is_etree_element_instance(root.value):
             return root.get_document_node()
 
         return root

elementpath/xpath1/_xpath1_functions.py

@@ -146,7 +146,7 @@ def select_id_function(self: XPathFunction, context: ContextType = None) \
 
     if isinstance(item, (ElementNode, DocumentNode)):
         for element in item.iter_descendants():
-            if isinstance(element, EtreeElementNode) and element.obj.get(XML_ID) == value:
+            if isinstance(element, EtreeElementNode) and element.value.get(XML_ID) == value:
                 yield element
 
 
@@ -380,11 +380,11 @@ def evaluate_lang_function(self: XPathFunction, context: ContextType = None) ->
         return False
     else:
         try:
-            attr = context.item.obj.attrib[XML_LANG]
+            attr = context.item.value.attrib[XML_LANG]
         except KeyError:
             for e in context.iter_ancestors():
-                if isinstance(e, EtreeElementNode) and XML_LANG in e.obj.attrib:
-                    lang = e.obj.attrib[XML_LANG]
+                if isinstance(e, EtreeElementNode) and XML_LANG in e.value.attrib:
+                    lang = e.value.attrib[XML_LANG]
                     if not isinstance(lang, str):
                         return False
                     break

elementpath/xpath1/_xpath1_operators.py

@@ -673,7 +673,7 @@ def select_child_path(self: XPathToken, context: ContextType = None) \
                 elif result in items:
                     pass
                 elif isinstance(result, ElementNode):
-                    if result.obj not in items:
+                    if result.value not in items:
                         items.add(result)
                         yield result
                 else:
@@ -700,7 +700,7 @@ def select_descendant_path(self: XPathToken, context: ContextType = None) \
                     elif result in items:
                         pass
                     elif isinstance(result, ElementNode):
-                        if result.obj not in items:
+                        if result.value not in items:
                             items.add(result)
                             yield result
                     else:
@@ -723,7 +723,7 @@ def select_descendant_path(self: XPathToken, context: ContextType = None) \
                 elif result in items:
                     pass
                 elif isinstance(result, ElementNode):
-                    if result.obj not in items:
+                    if result.value not in items:
                         items.add(result)
                 else:
                     items.add(result)