elementpath 5.0.0__tar.gz → 5.0.2__tar.gz

{elementpath-5.0.0 → elementpath-5.0.2}/CHANGELOG.rst

@@ -2,6 +2,15 @@
 CHANGELOG
 *********
 
+`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)
+
 `v5.0.0`_ (2025-04-27)
 ======================
 * Replace SafeXMLParser with SafeExpatParser
@@ -502,3 +511,5 @@ CHANGELOG
 .. _v4.7.0: https://github.com/sissaschool/elementpath/compare/v4.6.0...v4.7.0
 .. _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

{elementpath-5.0.0/elementpath.egg-info → elementpath-5.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elementpath
-Version: 5.0.0
+Version: 5.0.2
 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.0 → elementpath-5.0.2}/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.0'
+release = '5.0.2'
 
 # -- General configuration ---------------------------------------------------
 

{elementpath-5.0.0 → elementpath-5.0.2}/elementpath/__init__.py

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

{elementpath-5.0.0 → elementpath-5.0.2}/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.0 → elementpath-5.0.2}/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.0 → elementpath-5.0.2}/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.0 → elementpath-5.0.2}/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.0 → elementpath-5.0.2}/elementpath/protocols.py

@@ -10,16 +10,14 @@
 """
 Define type hints protocols for XPath related objects.
 """
-from collections.abc import Hashable, Iterator, Iterable, ItemsView, Mapping, Sequence, Sized
-from typing import overload, Any, Optional, Protocol, Union, TypeVar, TYPE_CHECKING
+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
 
 from collections.abc import MutableMapping
 from elementpath.aliases import NamespacesType, NsmapType
 
-if TYPE_CHECKING:
-    from elementpath.schema_proxy import AbstractSchemaProxy
-
 _T = TypeVar("_T")
 _AnyStr = Union[str, bytes]
 
@@ -67,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]: ...
@@ -146,6 +144,9 @@ class XsdComponentProtocol(XsdValidatorProtocol, Protocol):
     @property
     def parent(self) -> Optional['XsdComponentProtocol']: ...
 
+    @property
+    def ref(self) -> Optional['XsdComponentProtocol']: ...
+
 
 class XsdTypeProtocol(XsdComponentProtocol, Protocol):
 
@@ -260,17 +261,29 @@ class XsdTypeProtocol(XsdComponentProtocol, Protocol):
         """
         ...
 
+    @property
+    def model_group(self) -> Optional['XsdGroupProtocol']:
+        """
+        A model group if it's a complexType with mixed or element-only content, `None` otherwise.
+        """
+        ...
 
-class XsdAttributeProtocol(XsdComponentProtocol, Protocol):
 
-    @property
-    def type(self) -> Optional[XsdTypeProtocol]: ...
+class XsdComplexTypeProtocol(XsdComponentProtocol, Protocol):
 
     @property
-    def ref(self) -> Optional[Any]: ...
+    def attributes(self) -> 'XsdAttributeGroupProtocol': ...
+
+
+class XsdGroupProtocol(XsdComponentProtocol, Protocol):
 
+    def iter_elements(self) -> Iterator['XsdElementProtocol']: ...
 
-XsdXPathNodeType = Union['XsdSchemaProtocol', 'XsdElementProtocol']
+
+class XsdAttributeProtocol(XsdComponentProtocol, Protocol):
+
+    @property
+    def type(self) -> Optional[XsdTypeProtocol]: ...
 
 
 class XsdAttributeGroupProtocol(XsdComponentProtocol, Protocol):
@@ -296,62 +309,40 @@ class XsdAttributeGroupProtocol(XsdComponentProtocol, Protocol):
 
     def __hash__(self) -> int: ...
 
-    @property
-    def ref(self) -> Optional[Any]: ...
-
 
 class XsdElementProtocol(XsdComponentProtocol, ElementProtocol, Protocol):
 
-    def __iter__(self) -> Iterator['XsdElementProtocol']: ...
-
-    def find(
-            self, path: str, namespaces: Optional[NamespacesType] = ...
-    ) -> Optional[XsdXPathNodeType]: ...
-    def iter(self, tag: Optional[str] = ...) -> Iterator['XsdElementProtocol']: ...
-
     @property
     def name(self) -> Optional[str]: ...
 
     @property
     def type(self) -> Optional[XsdTypeProtocol]: ...
 
-    @property
-    def ref(self) -> Optional[Any]: ...
-
     @property
     def attrib(self) -> XsdAttributeGroupProtocol: ...
 
-    @property
-    def xpath_proxy(self) -> 'AbstractSchemaProxy': ...
-
+    def __iter__(self) -> Iterator['XsdElementProtocol']: ...
 
-GT = TypeVar("GT")
-XsdGlobalValue = Union[GT, tuple[ElementProtocol, Any]]
+    def find(self, path: str, namespaces: Optional[NamespacesType] = ...) \
+        -> Union['XsdElementProtocol', None]: ...
 
 
 class GlobalMapsProtocol(Protocol):
 
     @property
-    def types(self) -> Mapping[str, XsdGlobalValue[XsdTypeProtocol]]: ...
+    def types(self) -> Mapping[str, XsdTypeProtocol]: ...
 
     @property
-    def attributes(self) -> Mapping[str, XsdGlobalValue[XsdAttributeProtocol]]: ...
+    def attributes(self) -> Mapping[str, XsdAttributeProtocol]: ...
 
     @property
-    def elements(self) -> Mapping[str, XsdGlobalValue[XsdElementProtocol]]: ...
+    def elements(self) -> Mapping[str, XsdElementProtocol]: ...
 
     @property
     def substitution_groups(self) -> Mapping[str, set[Any]]: ...
 
 
-class XsdSchemaProtocol(XsdValidatorProtocol, ElementProtocol, Protocol):
-
-    def __iter__(self) -> Iterator[XsdXPathNodeType]: ...
-
-    def find(
-            self, path: str, namespaces: Optional[NamespacesType] = ...
-    ) -> Optional[XsdXPathNodeType]: ...
-    def iter(self, tag: Optional[str] = ...) -> Iterator[XsdXPathNodeType]: ...
+class XsdSchemaProtocol(XsdValidatorProtocol, Protocol):
 
     @property
     def validity(self) -> str: ...
@@ -365,10 +356,13 @@ class XsdSchemaProtocol(XsdValidatorProtocol, ElementProtocol, Protocol):
     @property
     def attrib(self) -> MutableMapping[Optional[str], 'XsdAttributeProtocol']: ...
 
-    @property
-    def xpath_proxy(self) -> 'AbstractSchemaProxy': ...
+    def __iter__(self) -> Iterator['XsdXPathNodeType']: ...
+
+    def find(self, path: str, namespaces: Optional[NamespacesType] = ...) \
+        -> Union['XsdSchemaProtocol', 'XsdElementProtocol', None]: ...
 
 
+XsdXPathNodeType = Union[XsdSchemaProtocol, XsdElementProtocol]
 DocumentType = Union[ElementTree, DocumentProtocol]
 ElementType = Union[Element, ElementProtocol]
 SchemaElemType = Union[XsdSchemaProtocol, XsdElementProtocol]
@@ -386,4 +380,5 @@ __all__ = ['ElementProtocol', 'EtreeElementProtocol', 'LxmlAttribProtocol',
            'XsdValidatorProtocol', 'XsdComponentProtocol', 'XsdTypeProtocol',
            'XsdAttributeProtocol', 'XsdAttributeGroupProtocol', 'XsdElementProtocol',
            'GlobalMapsProtocol', 'XsdSchemaProtocol', 'DocumentType', 'ElementType',
-           'SchemaElemType', 'CommentType', 'ProcessingInstructionType', 'AttribType']
+           'SchemaElemType', 'CommentType', 'ProcessingInstructionType',
+           'AttribType', 'XsdXPathNodeType']

{elementpath-5.0.0 → elementpath-5.0.2}/elementpath/regex/categories_fallback.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 #
 # Copyright (c), 2025, SISSA (International School for Advanced Studies).
 # All rights reserved.

{elementpath-5.0.0 → elementpath-5.0.2}/elementpath/schema_proxy.py

@@ -10,19 +10,20 @@
 from abc import ABCMeta, abstractmethod
 from collections.abc import Iterator
 from functools import lru_cache
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import cast, Any, Optional, Union
 
 from elementpath.exceptions import ElementPathTypeError
 from elementpath.protocols import XsdTypeProtocol, XsdAttributeProtocol, \
-    XsdElementProtocol, XsdSchemaProtocol
+    XsdElementProtocol, XsdSchemaProtocol, XsdAttributeGroupProtocol
+from elementpath.namespaces import XSD_ANY_ATOMIC_TYPE
 from elementpath.datatypes import AtomicType
 from elementpath.etree import is_etree_element
 from elementpath.xpath_context import XPathSchemaContext
-
-if TYPE_CHECKING:
-    from elementpath.xpath_tokens import XPath2ParserType
+from elementpath.xpath_tokens import XPath2ParserType
 
 PathResult = Union[XsdSchemaProtocol, XsdElementProtocol, XsdAttributeProtocol]
+FindAttrType = Optional[XsdAttributeProtocol]
+FindElemType = Optional[XsdElementProtocol]
 
 
 class AbstractSchemaProxy(metaclass=ABCMeta):
@@ -33,7 +34,7 @@ class AbstractSchemaProxy(metaclass=ABCMeta):
     :param schema: a schema instance compatible with the XsdSchemaProtocol.
     :param base_element: the schema element used as base item for static analysis.
     """
-    __slots__ = ('_schema', '_base_element', '_find', '_is_fully_valid')
+    __slots__ = ('_schema', '_base_element', '_is_fully_valid')
 
     def __init__(self, schema: XsdSchemaProtocol,
                  base_element: Optional[XsdElementProtocol] = None) -> None:
@@ -48,12 +49,6 @@ class AbstractSchemaProxy(metaclass=ABCMeta):
 
         self._schema = schema
         self._base_element: Optional[XsdElementProtocol] = base_element
-
-        if self._base_element is not None:
-            self._find = self._base_element.find
-        else:
-            self._find = self._schema.find
-
         self._is_fully_valid = False
 
     @property
@@ -109,24 +104,26 @@ class AbstractSchemaProxy(metaclass=ABCMeta):
     def find(self, path: str, namespaces: Optional[dict[str, str]] = None) \
             -> Optional[PathResult]:
         """
-        Find a schema element or attribute using an XPath expression.
+        Find a schema element or attribute using an XPath expression. Currently unused
+        in the code, it may be deprecated in the future.
 
         :param path: an XPath expression that selects an element or an attribute node.
         :param namespaces: an optional mapping from namespace prefix to namespace URI.
         :return: The first matching schema component, or ``None`` if there is no match.
         """
-        return self._find(path, namespaces)
+        if self._base_element is not None:
+            return self._base_element.find(path, namespaces=namespaces)
+        return self._schema.find(path, namespaces)
 
     @lru_cache(maxsize=None)
     def cached_find(self, expanded_path: str) -> Optional[PathResult]:
         """
-        Find a schema element or attribute using an expanded path as XPath expression.
-
-        :param expanded_path: an XPath expression with qualified names already resolved \
-        to expanded form.
-        :return: The first matching schema component, or ``None`` if there is no match.
+        Find a schema element or attribute using an expanded XPath expression.
+        Currently unused in the code, it may be deprecated in the future.
         """
-        return self._find(expanded_path)
+        if self._base_element is not None:
+            return self._base_element.find(expanded_path)
+        return self._schema.find(expanded_path)
 
     @property
     def xsd_version(self) -> str:
@@ -139,58 +136,98 @@ class AbstractSchemaProxy(metaclass=ABCMeta):
 
     def get_type(self, qname: str) -> Optional[XsdTypeProtocol]:
         """
-        Get the XSD global type from the schema's scope. A concrete implementation must
-        return an object that supports the protocols `XsdTypeProtocol`, or `None` if
-        the global type is not found.
+        Get the XSD global type from the schema's scope.
 
         :param qname: the fully qualified name of the type to retrieve.
         :returns: an object that represents an XSD type or `None`.
         """
-        xsd_type = self._schema.maps.types.get(qname)
-        if isinstance(xsd_type, tuple):
-            return None
-        return xsd_type
+        return self._schema.maps.types.get(qname)
 
     def get_attribute(self, qname: str) -> Optional[XsdAttributeProtocol]:
         """
-        Get the XSD global attribute from the schema's scope. A concrete implementation must
-        return an object that supports the protocol `XsdAttributeProtocol`, or `None` if
-        the global attribute is not found.
+        Get the XSD global attribute from the schema's scope.
 
         :param qname: the fully qualified name of the attribute to retrieve.
-        :returns: an object that represents an XSD attribute or `None`.
+        :returns: an object that represents an XSD type or `None`.
         """
-        xsd_attribute = self._schema.maps.attributes.get(qname)
-        if isinstance(xsd_attribute, tuple):
-            return None
-        return xsd_attribute
+        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. A concrete implementation must
-        return an object that supports the protocol `XsdElementProtocol` interface, or
-        `None` if the global element is not found.
+        Get the XSD global element from the schema's scope.
 
         :param qname: the fully qualified name of the element to retrieve.
-        :returns: an object that represents an XSD element or `None`.
+        :returns: an object that represents an XSD type or `None`.
         """
-        xsd_element = self._schema.maps.elements.get(qname)
-        if isinstance(xsd_element, tuple):
-            return None
-        return xsd_element
+        return self._schema.maps.elements.get(qname)
 
     def get_substitution_group(self, qname: str) -> Optional[set[XsdElementProtocol]]:
         """
-        Get a substitution group. A concrete implementation must return a list containing
-        substitution elements or `None` if the substitution group is not found. Moreover,
-        each item of the returned list must be an object that implements the
-        `AbstractXsdElement` interface.
+        Get a substitution group. Currently unused in the code, it may be deprecated
+        in the future.
 
         :param qname: the fully qualified name of the substitution group to retrieve.
         :returns: a list containing substitution elements or `None`.
         """
         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-5.0.0 → elementpath-5.0.2}/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