elementpath 5.0.1__tar.gz → 5.0.3__tar.gz

{elementpath-5.0.1 → elementpath-5.0.3}/CHANGELOG.rst

@@ -2,6 +2,15 @@
 CHANGELOG
 *********
 
+`v5.0.3`_ (2025-06-28)
+======================
+* Fix for XPath 1.0 processing of schema annotated XML data (issue #93)
+
+`v5.0.2`_ (2025-06-18)
+======================
+* Fix for XPath 2.0 *fn:node-name* (issue #91)
+* Workaround for processing arguments with multiple occurrences for external functions (issue #92)
+
 `v5.0.1`_ (2025-05-11)
 ======================
 * Fix XDM type labeling with element and xsi:type substitutions (issue #89)
@@ -507,3 +516,5 @@ CHANGELOG
 .. _v4.8.0: https://github.com/sissaschool/elementpath/compare/v4.7.0...v4.8.0
 .. _v5.0.0: https://github.com/sissaschool/elementpath/compare/v4.8.0...v5.0.0
 .. _v5.0.1: https://github.com/sissaschool/elementpath/compare/v5.0.0...v5.0.1
+.. _v5.0.2: https://github.com/sissaschool/elementpath/compare/v5.0.1...v5.0.2
+.. _v5.0.3: https://github.com/sissaschool/elementpath/compare/v5.0.2...v5.0.3

{elementpath-5.0.1/elementpath.egg-info → elementpath-5.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elementpath
-Version: 5.0.1
+Version: 5.0.3
 Summary: XPath 1.0/2.0/3.0/3.1 parsers and selectors for ElementTree and lxml
 Author-email: Davide Brunato <brunato@sissa.it>
 License-Expression: MIT

{elementpath-5.0.1 → elementpath-5.0.3}/doc/conf.py

@@ -31,7 +31,7 @@ author = 'Davide Brunato'
 # The short X.Y version
 version = '5.0'
 # The full version, including alpha/beta/rc tags
-release = '5.0.1'
+release = '5.0.3'
 
 # -- General configuration ---------------------------------------------------
 

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/__init__.py

@@ -7,7 +7,7 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
-__version__ = '5.0.1'
+__version__ = '5.0.3'
 __author__ = "Davide Brunato"
 __contact__ = "brunato@sissa.it"
 __copyright__ = "Copyright 2018-2025, SISSA"

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/compare.py

@@ -66,10 +66,17 @@ def deep_equal(seq1: Iterable[Any],
 
             if (value1 is None) ^ (value2 is None):
                 return False
+            elif isinstance(value1, (XPathArray, XPathMap, XPathNode)) ^ \
+                    isinstance(value2, (XPathArray, XPathMap, XPathNode)):
+                return False
             elif value1 is None:
                 return True
-            elif isinstance(value1, XPathNode) ^ isinstance(value2, XPathNode):
-                return False
+            elif isinstance(value1, XPathMap):
+                assert isinstance(value2, XPathMap)
+                return value1 == value2
+            elif isinstance(value1, XPathArray):
+                assert isinstance(value2, XPathArray)
+                return value1 == value2
             elif isinstance(value1, XPathNode):
                 assert isinstance(value2, XPathNode)
                 if value1.__class__ != value2.__class__:
@@ -187,9 +194,10 @@ def deep_compare(obj1: Any,
 
     def etree_deep_compare(e1: ElementProtocol, e2: ElementProtocol) -> int:
         nonlocal result
-        result = cm.strcoll(e1.tag, e2.tag)
-        if result:
-            return result
+        if not callable(e1.tag) and not callable(e2.tag):
+            result = cm.strcoll(e1.tag, e2.tag)
+            if result:
+                return result
 
         result = cm.strcoll((e1.text or '').strip(), (e2.text or '').strip())
         if result:
@@ -315,7 +323,8 @@ def deep_compare(obj1: Any,
 
                     elif isinstance(value1, float):
                         if math.isnan(value1):
-                            if not math.isnan(value2):
+                            if not isinstance(value2, (float, Decimal)) \
+                                    or not math.isnan(value2):
                                 return -1
                         elif math.isinf(value1):
                             if value1 != value2:

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/datatypes/datetime.py

@@ -258,7 +258,7 @@ class AbstractDateTime(AnyAtomicType):
         return cast(Timezone, self._dt.tzinfo)
 
     @tzinfo.setter
-    def tzinfo(self, tz: Timezone) -> None:
+    def tzinfo(self, tz: Optional[Timezone]) -> None:
         self._dt = self._dt.replace(tzinfo=tz)
 
     def tzname(self) -> Optional[str]:

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/etree.py

@@ -156,7 +156,7 @@ def etree_iter_paths(elem: ElementProtocol, path: str = '.') \
 
     for child in elem:
         if callable(child.tag):
-            if child.tag.__name__ == 'Comment':  # type: ignore[attr-defined]
+            if child.tag.__name__ == 'Comment':
                 comment_nodes += 1
                 yield child, f'{path}/comment()[{comment_nodes}]'
                 continue

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/helpers.py

@@ -84,7 +84,7 @@ class Patterns:
     # Regex patterns related to names and namespaces
     namespace_uri = LazyPattern(r'{([^}]+)}')
     expanded_name = LazyPattern(
-        r'^(?:{(?P<namespace>[^}]+)})?'
+        r'^(?:(?:Q{|{)(?P<namespace>[^}]*)})?'
         r'(?P<local>[^\d\W][\w\-.\u00B7\u0300-\u036F\u0387\u06DD\u06DE\u203F\u2040]*)$',
     )
     unbound_expanded_name = LazyPattern(
@@ -259,19 +259,20 @@ def not_equal(op1: Any, op2: Any) -> bool:
 
 
 def match_wildcard(name: Optional[str], wildcard: str) -> bool:
-    if name is None:
+    if not name:
         return False
-    elif wildcard == '*' or wildcard == '*:*':
+    elif wildcard in ('*', '{*}*'):
         return True
-    elif wildcard.startswith('*:'):
-        if name.startswith('{'):
-            return name.endswith(f'}}{wildcard[2:]}')
-        else:
-            return name == wildcard[2:]
-    elif wildcard.startswith('{') and wildcard.endswith('}*') or wildcard.endswith(':*'):
+    elif wildcard == '{}*':
+        return name[0] != '{' or name[:2] == '{}'
+    elif wildcard[-1] == '*':
         return name.startswith(wildcard[:-1])
-    else:
+    elif not wildcard.startswith('{*}'):
         return False
+    elif name[0] == '{':
+        return name.endswith(wildcard[2:])
+    else:
+        return name == wildcard[3:]
 
 
 def escape_json_string(s: str, escaped: bool = False) -> str:

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/protocols.py

@@ -10,7 +10,8 @@
 """
 Define type hints protocols for XPath related objects.
 """
-from collections.abc import Hashable, Iterator, Iterable, ItemsView, Mapping, Sequence, Sized
+from collections.abc import Callable, Hashable, Iterator, Iterable, \
+    ItemsView, Mapping, Sequence, Sized
 from typing import overload, Any, Optional, Protocol, Union, TypeVar
 from xml.etree.ElementTree import Element, ElementTree
 
@@ -64,7 +65,7 @@ class ElementProtocol(Sized, Hashable, Protocol):
     def get(self, key: str, default: Optional[_T] = None) -> Union[str, _T, None]: ...
 
     @property
-    def tag(self) -> str: ...
+    def tag(self) -> Union[str, Callable[[], 'ElementProtocol']]: ...
 
     @property
     def text(self) -> Optional[str]: ...

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/serialization.py

@@ -20,6 +20,7 @@ from elementpath.datatypes import AnyAtomicType, AnyURI, AbstractDateTime, \
     AbstractBinary, UntypedAtomic, QName
 from elementpath.xpath_nodes import XPathNode, ElementNode, AttributeNode, DocumentNode, \
     NamespaceNode, TextNode, CommentNode
+from elementpath.xpath_nodes import EtreeElementNode
 from elementpath.xpath_tokens import XPathToken, XPathMap, XPathArray
 from elementpath.protocols import EtreeElementProtocol, LxmlElementProtocol
 
@@ -147,7 +148,9 @@ def get_serialization_params(params: Union[None, ElementNode, XPathMap] = None,
             raise xpath_error('SEPM0019', token=token)
 
         for child in root:
-            if child.tag == SER_PARAM_OMIT_XML_DECLARATION:
+            if callable(child.tag):
+                continue
+            elif child.tag == SER_PARAM_OMIT_XML_DECLARATION:
                 value = child.get('value')
                 if value not in ('yes', 'no') or len(child.attrib) > 1:
                     raise xpath_error('SEPM0017', token=token)
@@ -289,7 +292,8 @@ def serialize_to_xml(elements: Iterable[Any],
     chunks = []
     for item in iter_normalized(elements, item_separator):
         if isinstance(item, ElementNode):
-            item = item.obj
+            assert isinstance(item, EtreeElementNode)
+            elem = item.obj
         elif isinstance(item, (AttributeNode, NamespaceNode)):
             raise xpath_error('SENR0001', token=token)
         elif isinstance(item, TextNode):
@@ -306,15 +310,15 @@ def serialize_to_xml(elements: Iterable[Any],
 
         try:
             cks = etree_module.tostringlist(
-                item, encoding='utf-8', method=method, **kwargs
+                elem, encoding='utf-8', method=method, **kwargs
             )
         except TypeError:
-            ck = etree_module.tostring(item, encoding='utf-8', method=method)
-            chunks.append(ck.decode('utf-8').rstrip(item.tail))
+            ck = etree_module.tostring(elem, encoding='utf-8', method=method)
+            chunks.append(ck.decode('utf-8').rstrip(elem.tail))
         else:
             if cks and cks[0].startswith(b'<?'):
                 cks[0] = cks[0].replace(b'\'', b'"')
-            chunks.append(b'\n'.join(cks).decode('utf-8').rstrip(item.tail))
+            chunks.append(b'\n'.join(cks).decode('utf-8').rstrip(elem.tail))
 
     if not character_map:
         return (item_separator or '').join(chunks)
@@ -347,6 +351,7 @@ def serialize_to_json(elements: Iterable[Any],
                 if isinstance(obj, DocumentNode):
                     return ''.join(self.default(child) for child in obj)
                 elif isinstance(obj, ElementNode):
+                    assert isinstance(obj, EtreeElementNode)
                     elem = obj.obj
                     assert etree_module is not None
 

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/tree_builders.py

@@ -7,6 +7,7 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
+from collections import deque
 from collections.abc import Iterator
 from typing import cast, Any, Optional, Union
 
@@ -46,18 +47,13 @@ def get_node_tree(root: RootArgType,
     `False` is provided creates a dummy document when the root is an Element instance. \
     For default the root node kind is preserved.
     """
-    root_node: RootNodeType
-
     if isinstance(root, (DocumentNode, ElementNode)):
         if uri is not None and root.uri is None:
             root.tree.uri = uri
 
         if fragment:
             if isinstance(root, DocumentNode):
-                root_node = root.getroot()
-                if root_node.uri is None:
-                    root_node.uri = root.uri
-                return root_node
+                return root.getroot()
         elif fragment is False and \
                 isinstance(root, ElementNode) and \
                 is_etree_element_instance(root.obj):
@@ -80,9 +76,7 @@ def get_node_tree(root: RootArgType,
             cast(SchemaElemType, root), uri
         )
     else:
-        return build_node_tree(
-            cast(ElementTreeRootType, root), namespaces, uri, fragment
-        )
+        return build_node_tree(root, namespaces, uri, fragment)
 
 
 def build_node_tree(root: ElementTreeRootType,
@@ -146,8 +140,8 @@ def build_node_tree(root: ElementTreeRootType,
         position += 1
 
     children = iter(elem)
-    iterators: list[Any] = []
-    ancestors: list[Any] = []
+    iterators: deque[Any] = deque()
+    ancestors: deque[Any] = deque()
     parent = root_node
 
     while True:
@@ -160,7 +154,7 @@ def build_node_tree(root: ElementTreeRootType,
                     TextNode(elem.text, child, position)
                     position += 1
 
-            elif elem.tag.__name__ == 'Comment':  # type: ignore[attr-defined]
+            elif elem.tag.__name__ == 'Comment':
                 child = CommentNode(elem, parent, position)
                 position += 1
             else:
@@ -239,7 +233,8 @@ def build_lxml_node_tree(root: LxmlRootType,
 
         # Add root siblings (comments and processing instructions)
         for elem in reversed([x for x in root_elem.itersiblings(preceding=True)]):
-            if elem.tag.__name__ == 'Comment':  # type: ignore[attr-defined]
+            assert callable(elem.tag)
+            if elem.tag.__name__ == 'Comment':
                 CommentNode(elem, document_node, position)
                 position += 1
             else:
@@ -276,8 +271,8 @@ def build_lxml_node_tree(root: LxmlRootType,
         position += 1
 
     children = iter(root_elem)
-    iterators: list[Any] = []
-    ancestors: list[Any] = []
+    iterators: deque[Any] = deque()
+    ancestors: deque[Any] = deque()
     parent = root_node
 
     while True:
@@ -293,7 +288,7 @@ def build_lxml_node_tree(root: LxmlRootType,
                     TextNode(elem.text, child, position)
                     position += 1
 
-            elif elem.tag.__name__ == 'Comment':  # type: ignore[attr-defined]
+            elif elem.tag.__name__ == 'Comment':
                 child = CommentNode(elem, parent, position)
                 position += 1
             else:
@@ -319,7 +314,8 @@ def build_lxml_node_tree(root: LxmlRootType,
 
                 # Add root following siblings (comments and processing instructions)
                 for elem in root_elem.itersiblings():
-                    if elem.tag.__name__ == 'Comment':  # type: ignore[attr-defined]
+                    assert callable(elem.tag)
+                    if elem.tag.__name__ == 'Comment':
                         CommentNode(elem, document_node, position)
                         position += 1
                     else:

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/xpath1/_xpath1_operators.py

@@ -124,7 +124,7 @@ class _PrefixedReferenceToken(XPathToken):
         prefix = self[0].value
         assert isinstance(prefix, str)
         if prefix == '*':
-            return '*:%s' % self[1].value
+            return '{*}%s' % self[1].value
         else:
             return f'{{{self.get_namespace(prefix)}}}{self[1].value}'
 
@@ -224,10 +224,12 @@ def nud_namespace_uri(self: XPathToken) -> XPathToken:
     cls: type[XPathToken] = self.parser.symbol_table['(string)']
     self[:] = cls(self.parser, namespace), self.parser.expression(90)
 
-    if not self[0].value:
-        self.value = self[1].value
-    else:
+    if self[0].value:
         self.value = f'{{{self[0].value}}}{self[1].value}'
+    elif self[1].value == '*':
+        self.value = '{}*'
+    else:
+        self.value = self[1].value
     return self
 
 

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/xpath1/xpath1_parser.py

@@ -277,8 +277,10 @@ class XPath1Parser(Parser[XPathTokenType]):
                 not isinstance(self.next_token, (XPathFunction, XPathAxis)) and \
                 self.name_pattern.match(self.next_token.symbol) is not None:
             # Disambiguation replacing the next token with a '(name)' token
-            cls = cast(type[XPathToken], self.symbol_table['(name)'])
-            self.next_token = cls(self, self.next_token.symbol)
+            cls = self.symbol_table['(name)']
+            assert not issubclass(cls, XPathFunction)
+            value = self.next_token.symbol
+            self.next_token = cls(self, value)
         else:
             raise self.next_token.wrong_syntax(message)
 

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/xpath2/_xpath2_functions.py

@@ -272,8 +272,13 @@ def evaluate_node_name_function(self: XPathFunction, context: ContextType = None
     elif name.startswith('{'):
         # name is a QName in extended format
         namespace, local_name = split_expanded_name(name)
+        if not namespace:
+            return QName('', local_name)
+
         for pfx, uri in self.parser.namespaces.items():
             if uri == namespace:
+                if not pfx:
+                    return QName(uri, local_name)
                 return QName(uri, '{}:{}'.format(pfx, local_name))
         raise self.error('FONS0004', 'no prefix found for namespace {}'.format(namespace))
     else:

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/xpath2/xpath2_parser.py

@@ -10,6 +10,7 @@
 """
 XPath 2.0 implementation - part 1 (parser class and symbols)
 """
+import copy
 from abc import ABCMeta
 import locale
 from collections.abc import Callable, MutableMapping
@@ -355,7 +356,7 @@ class XPath2Parser(XPath1Parser):
         )
 
         if self.symbol_table is self.__class__.symbol_table:
-            self.symbol_table = dict(self.__class__.symbol_table)
+            self.symbol_table = copy.copy(self.symbol_table)
         self.symbol_table[symbol] = token_class
         self.tokenizer = None
 
@@ -399,7 +400,7 @@ class XPath2Parser(XPath1Parser):
         lookup_name = qname.expanded_name
 
         if self.symbol_table is self.__class__.symbol_table:
-            self.symbol_table = dict(self.__class__.symbol_table)
+            self.symbol_table = copy.copy(self.symbol_table)
 
         if lookup_name in self.symbol_table:
             msg = f'function {qname.qname!r} is already registered'
@@ -439,7 +440,13 @@ class XPath2Parser(XPath1Parser):
                                        context: Optional[XPathContext] = None) -> Any:
             args = []
             for k in range(len(self_)):
-                arg = self_.get_argument(context, index=k)
+                try:
+                    if sequence_types[k][-1] in '+*':
+                        arg = self_[k].evaluate(context)
+                    else:
+                        arg = self_.get_argument(context, index=k)
+                except IndexError:
+                    arg = self_.get_argument(context, index=k)
                 args.append(arg)
 
             if sequence_types:

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/xpath30/_xpath30_functions.py

@@ -25,7 +25,6 @@ from urllib.request import urlopen
 from urllib.error import URLError
 
 from elementpath.aliases import Emptiable
-from elementpath.protocols import ElementProtocol
 from elementpath.exceptions import ElementPathError
 from elementpath.tdop import MultiLabel
 from elementpath.helpers import OCCURRENCE_INDICATORS, Patterns, \
@@ -660,7 +659,7 @@ def evaluate_format_number_function(self: XPathFunction, context: ContextType =
 
     minus_sign = decimal_format['minus-sign']
 
-    prefix = ''
+    prefix: str = ''
     if value >= 0:
         subpic = sub_pictures[0]
     else:
@@ -683,7 +682,8 @@ def evaluate_format_number_function(self: XPathFunction, context: ContextType =
         suffix = percent_sign
         subpic = subpic[:-1]
 
-        if value.as_tuple().exponent < 0:
+        exponent = value.as_tuple().exponent
+        if isinstance(exponent, int) and exponent < 0:
             value *= 100
         else:
             value = decimal.Decimal(int(value) * 100)
@@ -692,7 +692,8 @@ def evaluate_format_number_function(self: XPathFunction, context: ContextType =
         suffix = per_mille_sign
         subpic = subpic[:-1]
 
-        if value.as_tuple().exponent < 0:
+        exponent = value.as_tuple().exponent
+        if isinstance(exponent, int) and exponent < 0:
             value *= 1000
         else:
             value = decimal.Decimal(int(value) * 1000)
@@ -931,7 +932,7 @@ def evaluate_format_date_time_functions(self: XPathFunction, context: ContextTyp
                  sequence_types=('xs:string?', 'xs:string', 'xs:string',
                                  'element(fn:analyze-string-result)')))
 def evaluate_analyze_string_function(self: XPathFunction, context: ContextType = None) \
-        -> ElementProtocol:
+        -> ElementNode:
     if self.context is not None:
         context = self.context
 
@@ -1055,7 +1056,7 @@ def evaluate_analyze_string_function(self: XPathFunction, context: ContextType =
     else:
         root = context.etree.XML(''.join(lines))
 
-    return cast(ElementProtocol, get_node_tree(root=root, namespaces=self.parser.namespaces))
+    return cast(ElementNode, get_node_tree(root=root, namespaces=self.parser.namespaces))
 
 
 ###
@@ -1760,6 +1761,9 @@ def evaluate_node_name_function(self: XPathFunction, context: ContextType = None
         elif name.startswith('{'):
             # name is a QName in extended format
             namespace, local_name = split_expanded_name(name)
+            if not namespace:
+                return QName('', local_name)
+
             for pfx, uri in self.parser.namespaces.items():
                 if uri == namespace:
                     if not pfx:

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/xpath31/_xpath31_functions.py

@@ -709,7 +709,7 @@ def evaluate_parse_json_functions(self: XPathFunction, context: ContextType = No
         if json_text is None:
             return []
 
-    def _fallback(*args: Any, context: ContextType = None) -> str:
+    def _fallback(*a: Any, **kw: Any) -> str:
         return '\uFFFD'
 
     liberal = False
@@ -748,7 +748,7 @@ def evaluate_parse_json_functions(self: XPathFunction, context: ContextType = No
                 fallback = cast(Callable[..., str], v)
                 escape = False
 
-    def decode_value(value: SequenceType[ItemType]) -> ItemType:
+    def decode_value(value: SequenceType[ItemType]) -> Emptiable[ItemType]:
         if value is None:
             return []
         elif isinstance(value, list):
@@ -765,6 +765,8 @@ def evaluate_parse_json_functions(self: XPathFunction, context: ContextType = No
 
     def json_object_pairs_to_map(obj: Iterable[tuple[str, SequenceType[ItemType]]]) -> XPathMap:
         items: dict[ItemType, SequenceType[ItemType]] = {}
+        key: Any
+        value: Any
 
         for item in obj:
             key, value = decode_value(item[0]), decode_value(item[1])
@@ -775,7 +777,7 @@ def evaluate_parse_json_functions(self: XPathFunction, context: ContextType = No
                     raise self.error('FOJS0003')
 
             if isinstance(value, list):
-                values = [decode_value(x) for x in value]
+                values: Any = [decode_value(x) for x in value]
                 items[key] = XPathArray(self.parser, values) if values else values
             else:
                 items[key] = value
@@ -1262,7 +1264,7 @@ def evaluate_json_to_xml_function(self: XPathFunction, context: ContextType = No
     else:
         raise self.missing_context()
 
-    def _fallback(*args: Any, context: ContextType = None) -> str:
+    def _fallback(*a: Any, **kw: Any) -> str:
         return '�'
 
     liberal = False

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/xpath_context.py

@@ -617,7 +617,7 @@ class XPathContext:
             for item in root.iter_descendants(with_self=False):
                 if position < item.position and item not in descendants:
                     self.item = item
-                    yield cast(ChildNodeType, self.item)
+                    yield item
 
             self.item, self.axis = status
 

{elementpath-5.0.1 → elementpath-5.0.3}/elementpath/xpath_nodes.py

@@ -194,6 +194,10 @@ class XPathNode:
         """Access to wrapped object using the old API."""
         return self.obj
 
+    @property
+    def compat_string_value(self) -> str:
+        return self.string_value
+
     @property
     def root_node(self) -> 'XPathNode':
         return self if self.parent is None else self.parent.tree.root_node
@@ -1099,6 +1103,7 @@ class EtreeElementNode(ElementNode):
                  position: int = 1,
                  nsmap: Union[NsmapType, NamespacesType, None] = None) -> None:
 
+        assert not callable(elem.tag)
         self.name = elem.tag
         self.obj = elem
         self.parent = parent
@@ -1177,10 +1182,14 @@ class EtreeElementNode(ElementNode):
         else:
             yield from get_atomic_sequence(self.xsd_type, '')
 
+    @property
+    def compat_string_value(self) -> str:
+        return ''.join(etree_iter_strings(self.obj))
+
     def apply_schema(self, schema: 'AbstractSchemaProxy') -> None:
-        if self.schema is schema and not schema.is_assertion_based():
+        if self.tree.schema is schema and not schema.is_assertion_based():
             return
-        self.schema = schema
+        self.tree.schema = schema
 
         if not schema.is_fully_valid():
             element_type = schema.get_type(XSD_ANY_TYPE)
@@ -1213,7 +1222,7 @@ class EtreeElementNode(ElementNode):
             xsd_types = [None]
             children = iter((root_node,))
 
-        iterators: list[Any] = []
+        iterators: deque[Any] = deque()
         while True:
             for elem in children:
                 if not isinstance(elem, EtreeElementNode):
@@ -1266,15 +1275,15 @@ class EtreeElementNode(ElementNode):
 
     def match_name(self, name: str, default_namespace: Optional[str] = None) -> bool:
         if '*' in name:
-            return match_wildcard(self.obj.tag, name)
+            return match_wildcard(self.name, name)
         elif not name:
-            return not self.obj.tag
+            return not self.name
         elif hasattr(self.obj, 'type') and hasattr(self.obj, 'is_matching'):
             return cast(XsdElementProtocol, self.obj).is_matching(name, default_namespace)
         elif name[0] == '{' or not default_namespace:
-            return self.obj.tag == name
+            return self.name == name
         else:
-            return self.obj.tag == f'{{{default_namespace}}}{name}'
+            return self.name == f'{{{default_namespace}}}{name}'
 
     def get_document_node(self, replace: bool = False, as_parent: bool = True) -> 'DocumentNode':
         """
@@ -1353,7 +1362,7 @@ class LazyElementNode(EtreeElementNode):
                 for elem in self.obj:
                     if not callable(elem.tag):
                         LazyElementNode(elem, self)
-                    elif elem.tag.__name__ == 'Comment':  # type: ignore[attr-defined]
+                    elif elem.tag.__name__ == 'Comment':
                         CommentNode(elem, self)
                     else:
                         ProcessingInstructionNode(elem, parent=self)
@@ -1439,9 +1448,9 @@ class SchemaElementNode(ElementNode):
 
     def match_name(self, name: str, default_namespace: Optional[str] = None) -> bool:
         if '*' in name:
-            return match_wildcard(self.obj.tag, name)
+            return match_wildcard(self.name, name)
         elif not name:
-            return not self.obj.tag
+            return not self.name
         elif hasattr(self.obj, 'type'):
             return self.obj.is_matching(name, default_namespace)
         else:
@@ -1733,6 +1742,12 @@ class EtreeDocumentNode(DocumentNode):
             return ''.join(etree_iter_strings(root))
         return ''.join(child.string_value for child in self.children)
 
+    @property
+    def compat_string_value(self) -> str:
+        if not self.children:
+            return self.string_value
+        return ''.join(child.compat_string_value for child in self.children)
+
     @property
     def is_extended(self) -> bool:
         """