elementpath 4.6.0__tar.gz → 4.7.0__tar.gz

{elementpath-4.6.0 → elementpath-4.7.0}/CHANGELOG.rst

@@ -2,6 +2,11 @@
 CHANGELOG
 *********
 
+`v4.7.0`_ (2024-12-20)
+======================
+* Fix *fragment* argument usage (issue #81)
+* Fix constructors nud() to skip argument check with XP31+ arrow operator (issue #83)
+
 `v4.6.0`_ (2024-10-27)
 ======================
 * Fix XsdAttributeGroupProtocol
@@ -478,3 +483,4 @@ CHANGELOG
 .. _v4.4.0: https://github.com/sissaschool/elementpath/compare/v4.3.0...v4.4.0
 .. _v4.5.0: https://github.com/sissaschool/elementpath/compare/v4.4.0...v4.5.0
 .. _v4.6.0: https://github.com/sissaschool/elementpath/compare/v4.5.0...v4.6.0
+.. _v4.7.0: https://github.com/sissaschool/elementpath/compare/v4.6.0...v4.7.0

{elementpath-4.6.0 → elementpath-4.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: elementpath
-Version: 4.6.0
+Version: 4.7.0
 Summary: XPath 1.0/2.0/3.0/3.1 parsers and selectors for ElementTree and lxml
 Home-page: https://github.com/sissaschool/elementpath
 Author: Davide Brunato

{elementpath-4.6.0 → elementpath-4.7.0}/doc/conf.py

@@ -29,9 +29,9 @@ copyright = '2018-2024, SISSA (International School for Advanced Studies)'
 author = 'Davide Brunato'
 
 # The short X.Y version
-version = '4.6'
+version = '4.7'
 # The full version, including alpha/beta/rc tags
-release = '4.6.0'
+release = '4.7.0'
 
 # -- General configuration ---------------------------------------------------
 

{elementpath-4.6.0 → elementpath-4.7.0}/elementpath/__init__.py

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

{elementpath-4.6.0 → elementpath-4.7.0}/elementpath/etree.py

@@ -106,7 +106,17 @@ def is_etree_element(obj: Any) -> bool:
 
 
 def is_lxml_etree_element(obj: Any) -> bool:
-    return is_etree_element(obj) and hasattr(obj, 'getparent') and hasattr(obj, 'nsmap')
+    return is_etree_element(obj) and \
+        hasattr(obj, 'getparent') and \
+        hasattr(obj, 'nsmap') and \
+        obj.__class__.__module__ in ('lxml.etree', 'lxml.html')
+
+
+def is_etree_element_instance(obj: Any) -> bool:
+    """Strictly checks that the objects is an ElementTree or lxml.etree Element."""
+    return isinstance(obj, ElementTree.Element) or \
+        isinstance(obj, PyElementTree.Element) or \
+        is_lxml_etree_element(obj)
 
 
 def is_etree_document(obj: Any) -> bool:
@@ -114,7 +124,17 @@ def is_etree_document(obj: Any) -> bool:
 
 
 def is_lxml_etree_document(obj: Any) -> bool:
-    return is_etree_document(obj) and hasattr(obj, 'xpath') and hasattr(obj, 'xslt')
+    return is_etree_document(obj) and \
+        hasattr(obj, 'xpath') and \
+        hasattr(obj, 'xslt') and \
+        obj.__class__.__module__ in ('lxml.etree', 'lxml.html')
+
+
+def is_etree_document_instance(obj: Any) -> bool:
+    """Strictly checks that the objects is an ElementTree or lxml.etree document."""
+    return isinstance(obj, ElementTree.ElementTree) or \
+        isinstance(obj, PyElementTree.ElementTree) or \
+        is_lxml_etree_document(obj)
 
 
 def etree_iter_strings(elem: Union[DocumentProtocol, ElementProtocol],
@@ -237,7 +257,7 @@ def etree_tostring(elem: ElementProtocol,
             return indent + line
 
     etree_module: Any
-    if not is_etree_element(elem):
+    if not is_etree_element_instance(elem):
         raise TypeError(f"{elem!r} is not an Element")
     elif isinstance(elem, PyElementTree.Element):
         etree_module = PyElementTree
@@ -308,6 +328,6 @@ def etree_tostring(elem: ElementProtocol,
 
 
 __all__ = ['ElementTree', 'PyElementTree', 'SafeXMLParser', 'defuse_xml',
-           'is_etree_element', 'is_lxml_etree_element', 'is_etree_document',
-           'is_lxml_etree_document', 'etree_iter_strings', 'etree_deep_equal',
-           'etree_iter_paths', 'etree_tostring']
+           'is_etree_element', 'is_lxml_etree_element', 'is_etree_element_instance',
+           'is_etree_document', 'is_lxml_etree_document', 'is_etree_document_instance',
+           'etree_iter_strings', 'etree_deep_equal', 'etree_iter_paths', 'etree_tostring']

{elementpath-4.6.0 → elementpath-4.7.0}/elementpath/tree_builders.py

@@ -14,7 +14,7 @@ from elementpath.aliases import NamespacesType
 from elementpath.exceptions import ElementPathTypeError
 from elementpath.protocols import ElementProtocol, LxmlElementProtocol, \
     DocumentProtocol, LxmlDocumentProtocol, XsdElementProtocol
-from elementpath.etree import is_etree_document, is_etree_element
+from elementpath.etree import is_etree_document, is_etree_element, is_etree_element_instance
 from elementpath.xpath_nodes import SchemaElemType, ChildNodeType, \
     ElementMapType, TextNode, CommentNode, ProcessingInstructionNode, \
     ElementNode, SchemaElementNode, DocumentNode
@@ -36,7 +36,7 @@ def is_schema(obj: Any) -> bool:
 def get_node_tree(root: RootArgType,
                   namespaces: Optional[NamespacesType] = None,
                   uri: Optional[str] = None,
-                  fragment: Optional[bool] = False) -> Union[DocumentNode, ElementNode]:
+                  fragment: Optional[bool] = None) -> Union[DocumentNode, ElementNode]:
     """
     Returns a tree of XPath nodes that wrap the provided root tree.
 
@@ -44,64 +44,69 @@ def get_node_tree(root: RootArgType,
     :param namespaces: an optional mapping from prefixes to namespace URIs, \
     Ignored if root is a lxml etree or a schema structure.
     :param uri: an optional URI associated with the root element or the document.
-    :param fragment: if `True` a root element is considered a fragment, if `False` \
-    a root element is considered the root of an XML document. If the root is a \
-    document node or an ElementTree instance, and fragment is `True` then use the \
-    root element and returns an element node. If `None` is provided, the root node \
-    kind is preserved.
+    :param fragment: if `True` is provided the root is considered a fragment. In this \
+    case if `root` is an ElementTree instance skips it and use the root Element. If \
+    `False` is provided creates a dummy document when the root is an Element instance. \
+    For default the root node kind is preserved.
     """
     if isinstance(root, (DocumentNode, ElementNode)):
         if uri is not None and root.uri is None:
             root.uri = uri
 
-        if fragment and isinstance(root, DocumentNode):
-            root_node = root.getroot()
-            if root_node.uri is None:
-                root_node.uri = root.uri
-            return root_node
+        if fragment:
+            if isinstance(root, DocumentNode):
+                root_node = root.getroot()
+                if root_node.uri is None:
+                    root_node.uri = root.uri
+                return root_node
+        elif fragment is False and \
+                isinstance(root, ElementNode) and \
+                is_etree_element_instance(root.elem):
+            return root.get_document_node(replace=False)
 
         return root
 
-    # If a fragment is requested remove the ElementTree instance
-    if is_etree_document(root):
-        _root = cast(DocumentProtocol, root).getroot() if fragment else root
-    elif is_etree_element(root) and not callable(cast(ElementProtocol, root).tag):
-        _root = root
-    else:
+    if not is_etree_document(root) and \
+            (not is_etree_element(root) or callable(cast(ElementProtocol, root).tag)):
         msg = "invalid root {!r}, an Element or an ElementTree or a schema node required"
         raise ElementPathTypeError(msg.format(root))
-
-    if hasattr(_root, 'xpath'):
+    elif hasattr(root, 'xpath'):
         # a lxml element tree data
         return build_lxml_node_tree(
-            cast(LxmlRootType, _root), uri, fragment
+            cast(LxmlRootType, root), uri, fragment
         )
-    elif hasattr(_root, 'xsd_version') and hasattr(_root, 'maps'):
+    elif hasattr(root, 'xsd_version') and hasattr(root, 'maps'):
         # a schema or a schema node
         return build_schema_node_tree(
             cast(SchemaElemType, root), uri
         )
     else:
         return build_node_tree(
-            cast(ElementTreeRootType, root), namespaces, uri
+            cast(ElementTreeRootType, root), namespaces, uri, fragment
         )
 
 
 def build_node_tree(root: ElementTreeRootType,
                     namespaces: Optional[NamespacesType] = None,
-                    uri: Optional[str] = None) -> Union[DocumentNode, ElementNode]:
+                    uri: Optional[str] = None,
+                    fragment: Optional[bool] = None) -> Union[DocumentNode, ElementNode]:
     """
     Returns a tree of XPath nodes that wrap the provided root tree.
 
     :param root: an Element or an ElementTree.
     :param namespaces: an optional mapping from prefixes to namespace URIs.
     :param uri: an optional URI associated with the document or the root element.
+    :param fragment: if `True` is provided the root is considered a fragment. In this \
+    case if `root` is an ElementTree instance skips it and use the root Element. If \
+    `False` is provided creates a dummy document when the root is an Element instance. \
+    For default the root node kind is preserved.
     """
     elem: ElementProtocol
     parent: Any
     elements: Any
     child: ChildNodeType
     children: Iterator[Any]
+    document: Optional[DocumentProtocol]
 
     position = 1
     if namespaces:
@@ -111,10 +116,18 @@ def build_node_tree(root: ElementTreeRootType,
 
     if hasattr(root, 'parse'):
         document = cast(DocumentProtocol, root)
+        root_elem = document.getroot()
+    else:
+        document = None
+        root_elem = root
+
+    if fragment and root_elem is not None:
+        document = None  # Explicitly requested a fragment: don't create a document node
+
+    if document is not None:
         document_node = DocumentNode(document, uri, position)
         position += 1
 
-        root_elem = document.getroot()
         if root_elem is None:
             return document_node
 
@@ -123,8 +136,9 @@ def build_node_tree(root: ElementTreeRootType,
         elements = document_node.elements
         document_node.children.append(root_node)
     else:
+        assert root_elem is not None
         document_node = None
-        elem = root
+        elem = root_elem
         root_node = ElementNode(elem, None, position, namespaces)
         root_node.elements = elements = {}
         if uri is not None:
@@ -176,7 +190,14 @@ def build_node_tree(root: ElementTreeRootType,
             try:
                 children, parent = iterators.pop(), ancestors.pop()
             except IndexError:
-                return root_node if document_node is None else document_node
+                if document_node is not None:
+                    return document_node
+                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)
+                else:
+                    return root_node
             else:
                 if (tail := parent.children[-1].elem.tail) is not None:
                     parent.children.append(TextNode(tail, parent, position))
@@ -185,17 +206,19 @@ def build_node_tree(root: ElementTreeRootType,
 
 def build_lxml_node_tree(root: LxmlRootType,
                          uri: Optional[str] = None,
-                         fragment: Optional[bool] = False) -> Union[DocumentNode, ElementNode]:
+                         fragment: Optional[bool] = None) -> Union[DocumentNode, ElementNode]:
     """
     Returns a tree of XPath nodes that wrap the provided lxml root tree.
 
     :param root: a lxml Element or a lxml ElementTree.
     :param uri: an optional URI associated with the document or the root element.
-    :param fragment: if `True` a root element is considered a fragment, if `False` \
-    a root element is considered the root of an XML document. If `None` is provided, \
-    the root node kind is preserved.
+    :param fragment: if `True` is provided the root is considered a fragment. In this \
+    case if `root` is an ElementTree instance skips it and use the root Element. If \
+    `False` is provided creates a dummy document when the root is an Element instance. \
+    For default the root node kind is preserved.
     """
     root_node: Union[DocumentNode, ElementNode]
+    document: Optional[LxmlDocumentProtocol]
     parent: Any
     elements: Any
     child: ChildNodeType
@@ -204,18 +227,16 @@ def build_lxml_node_tree(root: LxmlRootType,
     position = 1
 
     if fragment:
-        # Explicitly requested a fragment: don't create a document node.
-        document = None
+        document = None  # Explicitly requested a fragment: don't create a document node
     elif hasattr(root, 'parse'):
-        # A document (ElementTree instance)
         document = cast(LxmlDocumentProtocol, root)
-    elif root.getparent() is None and (
+    elif fragment is False or root.getparent() is None and (
             any(True for _sibling in root.itersiblings(preceding=True)) or
             any(True for _sibling in root.itersiblings())):
-        # A root element with siblings, create a document for them.
+        # Despite a document is not explicitly requested create a dummy document
+        # because the root element has siblings
         document = root.getroottree()
     else:
-        # Explicitly provided a non-root element: do not parse root's siblings.
         document = None
 
     if document is not None:

{elementpath-4.6.0 → elementpath-4.7.0}/elementpath/xpath2/_xpath2_constructors.py

@@ -363,6 +363,8 @@ def evaluate_datetime_stamp_type(self: XPathConstructor, context: ContextType =
 def nud_datetime_stamp_type(self: XPathConstructor) -> XPathConstructor:
     if self.parser.xsd_version == '1.0':
         raise self.wrong_syntax("xs:dateTimeStamp is not recognized unless XSD 1.1 is enabled")
+    if not self.parser.parse_arguments:
+        return self
 
     try:
         self.parser.advance('(')
@@ -422,6 +424,9 @@ def cast_notation_type(self: XPathConstructor, value: AtomicType) -> Notation:
 
 @method('NOTATION')
 def nud_notation_type(self: XPathConstructor) -> None:
+    if not self.parser.parse_arguments:
+        return
+
     self.parser.advance('(')
     if self.parser.next_token.symbol == ')':
         raise self.error('XPST0017', 'expected exactly one argument')
@@ -454,6 +459,9 @@ def cast_boolean_type(self: XPathConstructor, value: AtomicType) -> bool:
 
 @method('boolean')
 def nud_boolean_type_and_function(self: XPathConstructor) -> XPathConstructor:
+    if not self.parser.parse_arguments:
+        return self
+
     self.parser.advance('(')
     if self.parser.next_token.symbol == ')':
         msg = 'Too few arguments: expected at least 1 argument'
@@ -502,6 +510,9 @@ def cast_string_type(self: XPathConstructor, value: AtomicType) -> str:
 
 @method('string')
 def nud_string_type_and_function(self: XPathConstructor) -> XPathConstructor:
+    if not self.parser.parse_arguments:
+        return self
+
     try:
         self.parser.advance('(')
         if self.label != 'function' or self.parser.next_token.symbol != ')':
@@ -576,6 +587,9 @@ def cast_datetime_type(self: XPathConstructor, value: AtomicType) \
 @method('QName')
 @method('dateTime')
 def nud_qname_and_datetime(self: XPathConstructor) -> XPathConstructor:
+    if not self.parser.parse_arguments:
+        return self
+
     try:
         self.parser.advance('(')
         self[0:] = self.parser.expression(5),

{elementpath-4.6.0 → elementpath-4.7.0}/elementpath/xpath2/xpath2_parser.py

@@ -249,6 +249,9 @@ class XPath2Parser(XPath1Parser):
         of the module where the method is called.
         """
         def nud_(self: XPathConstructor) -> XPathConstructor:
+            if not self.parser.parse_arguments:
+                return self
+
             try:
                 self.parser.advance('(')
                 self[0:] = self.parser.expression(5),

{elementpath-4.6.0 → elementpath-4.7.0}/elementpath/xpath30/_xpath30_functions.py

@@ -1492,7 +1492,7 @@ def evaluate_parse_xml_fragment_function(self: XPathFunction, context: ContextTy
         else:
             root = etree.XML(arg)
     except etree.ParseError as err:
-        # A not parsable fragment try to parse including XML data in a dummy element.
+        # A not parsable fragment: try to parse including XML data in a dummy element.
         try:
             dummy_element_node = get_node_tree(
                 root=etree.XML(f'<document>{arg}</document>'),
@@ -1502,7 +1502,7 @@ def evaluate_parse_xml_fragment_function(self: XPathFunction, context: ContextTy
             raise self.error('FODC0006', str(err)) from None
         else:
             assert isinstance(dummy_element_node, ElementNode)
-            return DocumentNode.from_element_node(dummy_element_node)
+            return dummy_element_node.get_document_node(replace=True)
     else:
         return cast(DocumentNode, get_node_tree(
             root=etree.ElementTree(root),
@@ -1955,6 +1955,9 @@ def cast_error_type(self: XPathConstructor, value: AtomicType) -> Emptiable[None
 @method('error')
 def nud_error_type_and_function(self: XPathConstructor) -> XPathConstructor:
     self.clear()
+    if not self.parser.parse_arguments:
+        return self
+
     try:
         self.parser.advance('(')
         if self.namespace == XSD_NAMESPACE:

{elementpath-4.6.0 → elementpath-4.7.0}/elementpath/xpath31/_xpath31_operators.py

@@ -235,6 +235,8 @@ def led_arrow_operator(self: XPathToken, left: XPathToken) -> XPathToken:
         self.parser.advance()
     elif isinstance(next_token, XPathFunction):
         self[:] = left, next_token
+        if next_token.label == 'kind test':
+            raise next_token.wrong_syntax()
         self.parser.advance()  # Skip static evaluation of function arguments
     else:
         next_token.expected('(name)', ':', 'Q{', '(')

{elementpath-4.6.0 → elementpath-4.7.0}/elementpath/xpath_context.py

@@ -19,9 +19,9 @@ from elementpath.protocols import ElementProtocol, DocumentProtocol
 from elementpath.exceptions import ElementPathTypeError
 from elementpath.tdop import Token
 from elementpath.datatypes import AnyAtomicType, AtomicType, Timezone, Language
-from elementpath.etree import is_etree_element, is_etree_document
+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, SchemaElementNode
+    CommentNode, ProcessingInstructionNode, ElementNode, DocumentNode
 from elementpath.tree_builders import RootArgType, get_node_tree
 
 if TYPE_CHECKING:
@@ -60,10 +60,11 @@ class XPathContext:
     This can be useful when the dynamic context has additional namespaces and root \
     is an Element or an ElementTree instance of the standard library.
     :param uri: an optional URI associated with the root element or the document.
-    :param fragment: if `True` a root element is considered a fragment, if `False` \
-    a root element is considered the root of an XML document, and a dummy document \
-    is created for selection. In this case the dummy document value is not included \
-    in the results. If `None` is provided, the root node kind is preserved.
+    :param fragment: if `True` is provided the root is considered a fragment. In this \
+    case if `root` is an ElementTree instance skips it and use the root Element. If \
+    `False` is provided creates a dummy document when the root is an Element instance. \
+    In this case the dummy document value is not included in results. For default the \
+    root node kind is preserved.
     :param item: the context item. A `None` value means that the context is positioned on \
     the document node.
     :param position: the current position of the node within the input sequence.
@@ -104,7 +105,7 @@ class XPathContext:
                  root: Optional[RootArgType] = None,
                  namespaces: Optional[NamespacesType] = None,
                  uri: Optional[str] = None,
-                 fragment: Optional[bool] = False,
+                 fragment: Optional[bool] = None,
                  item: Optional[ItemArgType] = None,
                  position: int = 1,
                  size: int = 1,
@@ -142,15 +143,11 @@ class XPathContext:
 
         if isinstance(self.root, DocumentNode):
             self.document = self.root
-        elif fragment or isinstance(self.root, SchemaElementNode):
-            pass
-        elif isinstance(self.root, ElementNode):
-            # Creates a dummy document
-            document = cast(DocumentProtocol, self.etree.ElementTree(self.root.elem))
-            self.document = DocumentNode(document, self.root.uri, position=0)
-            self.document.children.append(self.root)
-            self.document.elements = cast(Dict[ElementProtocol, ElementNode], self.root.elements)
-            # self.root.parent = self.document  TODO for v5? It's necessary?
+        elif fragment is None and \
+                isinstance(self.root, ElementNode) and \
+                is_etree_element_instance(self.root.elem):
+            # Creates a dummy document that will be not included in results
+            self.document = self.root.get_document_node(replace=False, as_parent=False)
 
         self.position = position
         self.size = size
@@ -214,12 +211,10 @@ class XPathContext:
             else:
                 module_name = 'xml.etree.ElementTree'
 
-            if not isinstance(module_name, str) or not module_name.startswith('lxml.'):
-                etree_module_name = 'xml.etree.ElementTree'
+            if module_name in ('lxml.etree', 'lxml.html'):
+                self._etree: ModuleType = importlib.import_module('lxml.etree')
             else:
-                etree_module_name = 'lxml.etree'
-
-            self._etree: ModuleType = importlib.import_module(etree_module_name)
+                self._etree = importlib.import_module('xml.etree.ElementTree')
 
         return self._etree
 
@@ -255,7 +250,7 @@ class XPathContext:
     def get_context_item(self, item: ItemArgType,
                          namespaces: Optional[NamespacesType] = None,
                          uri: Optional[str] = None,
-                         fragment: Optional[bool] = False) -> ItemType:
+                         fragment: Optional[bool] = None) -> ItemType:
         """
         Checks the item and returns an item suitable for XPath processing.
         For XML trees and elements try a match with an existing node in the