Fix XSD attributes lazy build

  - Remove AbstractSchemaProxy useless helper methods
    get_attribute_type and get_child_type. Code moved
    to EtreeElementNode.apply_schema() and attributes
    property.

Author: brunato

elementpath/schema_proxy.py

@@ -10,12 +10,11 @@
 from abc import ABCMeta, abstractmethod
 from collections.abc import Iterator
 from functools import lru_cache
-from typing import cast, Any, Optional, Union
+from typing import Any, Optional, Union
 
 from elementpath.exceptions import ElementPathTypeError
 from elementpath.protocols import XsdTypeProtocol, XsdAttributeProtocol, \
-    XsdElementProtocol, XsdSchemaProtocol, XsdAttributeGroupProtocol
-from elementpath.namespaces import XSD_ANY_ATOMIC_TYPE
+    XsdElementProtocol, XsdSchemaProtocol
 from elementpath.datatypes import AtomicType
 from elementpath.etree import is_etree_element
 from elementpath.xpath_context import XPathSchemaContext
@@ -143,47 +142,21 @@ def get_type(self, qname: str) -> Optional[XsdTypeProtocol]:
         """
         return self._schema.maps.types.get(qname)
 
-    def get_attribute(self, qname: str, parent_type: Optional[XsdTypeProtocol] = None) \
-            -> Optional[XsdAttributeProtocol]:
+    def get_attribute(self, qname: str) -> 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`.
         """
-        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, parent_type: Optional[XsdTypeProtocol] = None) \
-            -> Optional[XsdElementProtocol]:
+        return self._schema.maps.attributes.get(qname)
+
+    def get_element(self, qname: str,) -> Optional[XsdElementProtocol]:
         """
         Get the XSD global element 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 child element name. If `None` or not provided the scope is the schema.
-        :returns: an object that represents an XSD type or `None`.
         """
-        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
+        return self._schema.maps.elements.get(qname)
 
     def get_substitution_group(self, qname: str) -> Optional[set[XsdElementProtocol]]:
         """
@@ -195,63 +168,6 @@ def get_substitution_group(self, qname: str) -> Optional[set[XsdElementProtocol]
         """
         return self._schema.maps.substitution_groups.get(qname)
 
-    def get_attribute_type(self, name: str, parent_type: Optional[XsdTypeProtocol] = None) \
-            -> Optional[XsdTypeProtocol]:
-        """
-        Get the XSD attribute type if the provided name is matching in the scope,
-        otherwise return None.
-
-        :param name: the 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.
-        """
-        if parent_type is None:
-            try:
-                return self._schema.maps.attributes[name].type
-            except KeyError:
-                return None
-        elif hasattr(parent_type, 'attributes'):
-            attributes = cast(XsdAttributeGroupProtocol, parent_type.attributes)
-            if name in attributes:
-                return attributes[name].type
-            elif None in attributes and attributes[None].is_matching(name):
-                try:
-                    return self._schema.maps.attributes[name].type
-                except KeyError:
-                    return None
-            elif name.startswith('{http://www.w3.org/2001/XMLSchema-instance}'):
-                return self._schema.maps.types.get(XSD_ANY_ATOMIC_TYPE)
-
-        return None
-
-    def get_child_type(self, name: str, parent_type: Optional[XsdTypeProtocol] = None) \
-            -> Optional[XsdTypeProtocol]:
-        """
-        Get the child XSD type if the provided name is matching in the scope,
-        otherwise return None.
-
-        :param name: the name of the child element to match.
-        :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.
-        """
-        if parent_type is None:
-            try:
-                return self._schema.maps.elements[name].type
-            except KeyError:
-                return None
-        elif (content := parent_type.model_group) is not None:
-            for xsd_element in content.iter_elements():
-                if xsd_element.is_matching(name):
-                    if xsd_element.name == name:
-                        return xsd_element.type
-                    else:
-                        # a wildcard or a substitute
-                        try:
-                            return self._schema.maps.elements[name].type
-                        except KeyError:
-                            return None
-        return None
-
     @abstractmethod
     def is_instance(self, obj: Any, type_qname: str) -> bool:
         """

elementpath/xpath_nodes.py

@@ -1123,29 +1123,41 @@ def attributes(self) -> list[AttributeNode]:
                 for pos, (name, value) in enumerate(self.value.attrib.items(), position)
             ]
 
-            if self._attributes and self.xsd_type is not None \
-                    and (schema := self.tree.schema) is not None:
-                if self.xsd_type.name == XSD_ANY_TYPE:
-                    attribute_type = schema.get_type(XSD_ANY_SIMPLE_TYPE)
-                    for attr in self._attributes:
-                        attr.xsd_type = attribute_type
-                else:
-                    for attr in self._attributes:
-                        assert attr.name is not None
-                        attr.xsd_type = schema.get_attribute_type(attr.name, self.xsd_type)
+            if self.xsd_type is None or (schema := self.tree.schema) is None:
+                return self._attributes
+            elif not schema.is_fully_valid():
+                any_simple_type = schema.get_type(XSD_ANY_SIMPLE_TYPE)
+                for attr in self._attributes:
+                    attr.xsd_type = any_simple_type
+                return self._attributes
+            elif self.xsd_element is None or XSI_TYPE in self.value.attrib:
+                xsd_type = self.xsd_type
+            else:
+                xsd_type = cast(XsdTypeProtocol, self.xsd_element.type)
+
+            if hasattr(xsd_type, 'attributes'):
+                attributes = xsd_type.attributes
+                for attr in self._attributes:
+                    assert attr.name is not None
+                    if attr.name.startswith('{http://www.w3.org/2001/XMLSchema-instance}'):
+                        attr.xsd_type = schema.get_type(XSD_ANY_ATOMIC_TYPE)
+                    if attr.name in attributes:
+                        attr.xsd_type = attributes[attr.name].type
+                    elif None in attributes and attributes[None].is_matching(attr.name):
+                        xsd_attribute = schema.get_attribute(attr.name)
+                        if xsd_attribute is not None:
+                            attr.xsd_type = xsd_attribute.type
 
-            if self.xsd_element is not None:
                 # Add missing attributes with a default value, at the same
                 # position of the last attribute.
                 position = position + len(self.value.attrib)
-                for name, xsd_attribute in self.xsd_element.attrib.items():
-                    if name in self.value.attrib or name is None:
-                        continue
-
-                    if (value := getattr(xsd_attribute, 'value_constraint', None)) is not None:
-                        attr = TextAttributeNode(name, value, self, position)
-                        attr.xsd_type = xsd_attribute.type
-                        self._attributes.append(attr)
+                for name, xsd_attribute in attributes.items():
+                    if name is not None and name not in self.value.attrib:
+                        value = getattr(xsd_attribute, 'value_constraint', None)
+                        if value is not None:
+                            attr = TextAttributeNode(name, value, self, position)
+                            attr.xsd_type = xsd_attribute.type
+                            self._attributes.append(attr)
 
         return self._attributes
 
@@ -1216,7 +1228,8 @@ def apply_schema(self, schema: 'AbstractSchemaProxy') -> None:
             return
 
         if schema.base_element is not None:
-            xsd_types = [schema.base_element.type]
+            self.xsd_element = schema.base_element
+            xsd_types: list[Optional[XsdTypeProtocol]] = [schema.base_element.type]
             children: Iterator[Any] = iter(self)
             if schema.is_assertion_based():
                 self.xsd_type = schema.get_type(XSD_ANY_TYPE)
@@ -1250,15 +1263,27 @@ def apply_schema(self, schema: 'AbstractSchemaProxy') -> None:
                         continue
                     else:
                         xsd_type = schema.get_type(type_name)
-                        if xsd_type is None:
-                            node.clear_types()
-                            continue
                 else:
-                    node.xsd_element = schema.get_element(node.name, xsd_types[-1])
-                    if node.xsd_element is None:
-                        node.clear_types()
-                        continue
-                    xsd_type = node.xsd_element.type
+                    if xsd_types[-1] is None:
+                        xsd_element = schema.get_element(node.name)
+                    elif (content := xsd_types[-1].model_group) is None:
+                        xsd_element = None
+                    else:
+                        for xsd_element in content.iter_elements():
+                            if xsd_element.is_matching(node.name):
+                                if xsd_element.name != node.name:
+                                    # a wildcard or a substitute
+                                    xsd_element = schema.get_element(node.name)
+                                break
+                        else:
+                            xsd_element = None
+
+                    xsd_type = getattr(xsd_element, 'type', None)
+                    node.xsd_element = xsd_element
+
+                if xsd_type is None:
+                    node.clear_types()
+                    continue
 
                 node.xsd_type = xsd_type
                 if hasattr(node, '_attributes'):
@@ -1278,12 +1303,12 @@ def apply_schema(self, schema: 'AbstractSchemaProxy') -> None:
 
     def clear_types(self) -> None:
         """Clear XSD types for element node subtree."""
-        for elem in self.iter_descendants(with_self=True):
-            if isinstance(elem, EtreeElementNode):
-                elem.xsd_type = None
-                elem.xsd_element = None
-                for attr in elem.attributes:
-                    attr.xsd_type = None
+        for node in self.iter_descendants(with_self=True):
+            if isinstance(node, EtreeElementNode):
+                node.xsd_type = None
+                node.xsd_element = None
+                if hasattr(node, '_attributes'):
+                    delattr(node, '_attributes')
 
     @property
     def is_typed(self) -> bool: