elementpath 5.0.0__tar.gz → 5.0.1__tar.gz

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

@@ -2,6 +2,10 @@
 CHANGELOG
 *********
 
+`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 +506,4 @@ 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

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

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

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

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

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

@@ -11,15 +11,12 @@
 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 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]
 
@@ -146,6 +143,9 @@ class XsdComponentProtocol(XsdValidatorProtocol, Protocol):
     @property
     def parent(self) -> Optional['XsdComponentProtocol']: ...
 
+    @property
+    def ref(self) -> Optional['XsdComponentProtocol']: ...
+
 
 class XsdTypeProtocol(XsdComponentProtocol, Protocol):
 
@@ -260,17 +260,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 +308,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 +355,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 +379,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.1}/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.1}/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.1}/elementpath/tree_builders.py

@@ -61,7 +61,7 @@ def get_node_tree(root: RootArgType,
         elif fragment is False and \
                 isinstance(root, ElementNode) and \
                 is_etree_element_instance(root.obj):
-            return root.get_document_node(replace=False)
+            return root.get_document_node()
 
         return root
 
@@ -186,7 +186,7 @@ def build_node_tree(root: ElementTreeRootType,
                 elif fragment is False and \
                         isinstance(root_node, ElementNode) and \
                         is_etree_element_instance(root_node.elem):
-                    return root_node.get_document_node(replace=False)
+                    return root_node.get_document_node()
                 else:
                     return root_node
             else:
@@ -350,8 +350,8 @@ def build_schema_node_tree(root: SchemaElemType,
     :param global_elements: a list for schema global elements, used for linking \
     the elements declared by reference.
     """
-    parent: Any
-    elem: Any
+    parent: SchemaElementNode
+    elem: XsdElementProtocol
     child: SchemaElementNode
     children: Iterator[Any]
 
@@ -381,7 +381,11 @@ def build_schema_node_tree(root: SchemaElemType,
     local_nodes = {root: root_node}  # Irrelevant even if it's the schema
     ref_nodes: list[SchemaElementNode] = []
 
-    children = iter(root)
+    if is_schema(root):
+        children = iter(e for e in root.maps.elements.values() if e.maps is root.maps)
+    else:
+        children = iter(root)
+
     iterators: list[Any] = []
     ancestors: list[Any] = []
     parent = root_node
@@ -412,7 +416,7 @@ def build_schema_node_tree(root: SchemaElemType,
             except IndexError:
                 # connect references to proper nodes
                 for element_node in ref_nodes:
-                    elem = element_node.elem
+                    elem = cast(XsdElementProtocol, element_node.elem)
                     ref = cast(XsdElementProtocol, elem.ref)
 
                     other: Any

{elementpath-5.0.0 → elementpath-5.0.1}/elementpath/xpath2/_xpath2_operators.py

@@ -848,8 +848,7 @@ def select_schema_element_kind_test(self: XPathFunction, context: ContextType =
 
     if self.parser.schema is not None:
         for _ in context.iter_children_or_self():
-            if self.parser.schema.get_element(qname) is None \
-                    and self.parser.schema.get_substitution_group(qname) is None:
+            if self.parser.schema.get_element(qname) is None:
                 raise self.error('XPST0008', "element %r not found in schema" % element_name)
 
             if isinstance(context.item, ElementNode) and context.item.name == qname:

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

@@ -23,7 +23,7 @@ from elementpath.datatypes import AnyAtomicType, AtomicType, Timezone, Language
 from elementpath.etree import is_etree_element, is_etree_element_instance, is_etree_document
 from elementpath.xpath_nodes import ChildNodeType, XPathNode, AttributeNode, NamespaceNode, \
     CommentNode, ProcessingInstructionNode, ElementNode, DocumentNode, RootNodeType, \
-    RootArgType, SchemaElementNode
+    RootArgType
 from elementpath.tree_builders import get_node_tree
 
 if TYPE_CHECKING:
@@ -144,9 +144,6 @@ class XPathContext:
             else:
                 self.item = self.root
 
-            if schema is not None:
-                self.root.apply_schema(schema)
-
         elif item is not None:
             self.root = None
             self.item = self.get_context_item(item, self.namespaces, uri, fragment)
@@ -159,7 +156,7 @@ class XPathContext:
                 isinstance(self.root, ElementNode) and \
                 is_etree_element_instance(self.root.obj):
             # Creates a dummy document that will be not included in results
-            self.document = self.root.get_document_node(replace=False, as_parent=False)
+            self.document = self.root.get_document_node(as_parent=False)
         else:
             self.document = None
 
@@ -180,7 +177,9 @@ class XPathContext:
                 if v is not None else v for k, v in documents.items()
             }
 
-        self.schema = schema
+        if schema is not None:
+            self.schema = schema
+
         self.variables = {}
         if variables is not None:
             for varname, value in variables.items():
@@ -243,11 +242,21 @@ class XPathContext:
     @schema.setter
     def schema(self, schema: Optional['AbstractSchemaProxy']) -> None:
         self._schema = schema
-        if schema is not None:
+        if schema is None:
+            if self.root is not None:
+                self.root.clear_types()
+            elif isinstance(self.item, XPathNode):
+                self.item.clear_types()
+        elif hasattr(schema, 'is_assertion_based'):
             if self.root is not None:
+                self.root.clear_types()
                 self.root.apply_schema(schema)
             elif isinstance(self.item, XPathNode):
+                self.item.clear_types()
                 self.item.apply_schema(schema)
+        else:
+            msg = f"{schema!r} is not an instance of AbstractSchemaProxy"
+            raise ElementPathTypeError(msg)
 
     def get_root(self, node: Any) -> Optional[RootNodeType]:
         if isinstance(self.root, (DocumentNode, ElementNode)):
@@ -622,15 +631,6 @@ class XPathSchemaContext(XPathContext):
     """
     root: ElementNode
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        if self.schema is None:
-            if isinstance(self.root, SchemaElementNode):
-                try:
-                    self._schema = self.root.obj.xpath_proxy
-                except AttributeError:
-                    pass
-
     @property
     def schema(self) -> Optional['AbstractSchemaProxy']:
         return self._schema