elementpath 4.6.0__tar.gz → 4.8.0__tar.gz

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

@@ -2,6 +2,18 @@
 CHANGELOG
 *********
 
+`v4.8.0`_ (2025-03-03)
+======================
+* Add full PSVI type labeling in XDM to solve type errors with XSD 1.1 assertions
+* Add *schema* optional argument to dynamic context
+* Add a RootToken as a proxy of the parsed token tree for compatibility with xmlschema<=3.4.3
+* Extend XDM to split ElementTree/lxml processing from schema nodes and to allow future extensions
+
+`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 +490,5 @@ 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
+.. _v4.8.0: https://github.com/sissaschool/elementpath/compare/v4.7.0...v4.8.0

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: elementpath
-Version: 4.6.0
+Version: 4.8.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
@@ -40,6 +40,16 @@ Requires-Dist: memray; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: lxml-stubs; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
 
 ***********
 elementpath

{elementpath-4.6.0 → elementpath-4.8.0}/doc/advanced.rst

@@ -22,6 +22,11 @@ having as result a tree of tokens:
     >>> token = parser.parse('/root/(: comment :) child[@attr]')
     >>> isinstance(token, XPathToken)
     True
+
+That token is a proxy token for the tree produced by TDOP parsing:
+
+.. doctest::
+
     >>> token
     <_SolidusOperator object at 0x...
     >>> str(token)
@@ -73,7 +78,7 @@ represented by *XPathContext* objects.
     >>> root = ElementTree.XML('<root><child/><child attr="10"/></root>')
     >>> context = XPathContext(root)
     >>> token.evaluate(context)
-    [ElementNode(elem=<Element 'child' at ...)]
+    [EtreeElementNode(elem=<Element 'child' at ...)]
 
 In this case an error is raised if you don't provide a context:
 
@@ -124,9 +129,9 @@ Node trees are automatically created at dynamic context initialization:
     >>> root = ElementTree.XML('<root><child/><child attr="10"/></root>')
     >>> context = XPathContext(root)
     >>> context.root
-    ElementNode(elem=<Element 'root' at ...>)
+    EtreeElementNode(elem=<Element 'root' at ...>)
     >>> context.root.children
-    [ElementNode(elem=<Element 'child' at ...>), ElementNode(elem=<Element 'child' at ...>)]
+    [EtreeElementNode(elem=<Element 'child' at ...>), EtreeElementNode(elem=<Element 'child' at ...>)]
 
 If the same XML data is applied several times for dynamic evaluation it maybe
 convenient to build the node tree before, in the way to create it only once:
@@ -232,7 +237,7 @@ context item is set to context root:
 
     >>> context = XPathContext(doc)
     >>> context.root
-    DocumentNode(document=<xml.etree.ElementTree.ElementTree object at ...>)
+    EtreeDocumentNode(document=<xml.etree.ElementTree.ElementTree object at ...>)
     >>> context.item is context.root
     True
     >>> context.document is context.root
@@ -246,11 +251,11 @@ set to root element node. In this case the context document is a dummy document:
     >>> root = ElementTree.XML('<root><child1/><child2/><child3/></root>')
     >>> context = XPathContext(root)
     >>> context.root
-    ElementNode(elem=<Element 'root' at ...>)
+    EtreeElementNode(elem=<Element 'root' at ...>)
     >>> context.item is context.root
     True
     >>> context.document
-    DocumentNode(document=<xml.etree.ElementTree.ElementTree object at ...>)
+    EtreeDocumentNode(document=<xml.etree.ElementTree.ElementTree object at ...>)
     >>> context.root.parent is None
     True
 
@@ -263,7 +268,7 @@ the data with lxml:
     >>> root = etree.XML('<!-- comment --><root><child/></root>')
     >>> context = XPathContext(root)
     >>> context.root
-    DocumentNode(document=<lxml.etree._ElementTree object at ...>)
+    EtreeDocumentNode(document=<lxml.etree._ElementTree object at ...>)
     >>> context.item is context.root
     True
     >>> context.document is context.root
@@ -278,7 +283,7 @@ is set to `None`:
     >>> root = ElementTree.XML('<root><child1/><child2/><child3/></root>')
     >>> context = XPathContext(root, fragment=True)
     >>> context.root
-    ElementNode(elem=<Element 'root' at ...>)
+    EtreeElementNode(elem=<Element 'root' at ...>)
     >>> context.item is context.root
     True
     >>> context.document is None

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

@@ -25,13 +25,13 @@ sys.path.insert(0, os.path.abspath('..'))
 # -- Project information -----------------------------------------------------
 
 project = 'elementpath'
-copyright = '2018-2024, SISSA (International School for Advanced Studies)'
+copyright = '2018-2025, SISSA (International School for Advanced Studies)'
 author = 'Davide Brunato'
 
 # The short X.Y version
-version = '4.6'
+version = '4.8'
 # The full version, including alpha/beta/rc tags
-release = '4.6.0'
+release = '4.8.0'
 
 # -- General configuration ---------------------------------------------------
 

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

@@ -7,10 +7,10 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
-__version__ = '4.6.0'
+__version__ = '4.8.0'
 __author__ = "Davide Brunato"
 __contact__ = "brunato@sissa.it"
-__copyright__ = "Copyright 2018-2024, SISSA"
+__copyright__ = "Copyright 2018-2025, SISSA"
 __license__ = "MIT"
 __status__ = "Production/Stable"
 
@@ -26,9 +26,9 @@ from .exceptions import ElementPathError, MissingContextError, ElementPathKeyErr
     ElementPathValueError, ElementPathLocaleError, UnsupportedFeatureError
 
 from .xpath_context import XPathContext, XPathSchemaContext
-from .xpath_nodes import XPathNode, DocumentNode, ElementNode, AttributeNode, \
-    NamespaceNode,  CommentNode, ProcessingInstructionNode, TextNode, \
-    LazyElementNode, SchemaElementNode
+from .xpath_nodes import XPathNode, AttributeNode, NamespaceNode, CommentNode, \
+    ProcessingInstructionNode, TextNode, ElementNode, LazyElementNode, \
+    SchemaElementNode, DocumentNode
 from .tree_builders import get_node_tree, build_node_tree, build_lxml_node_tree, \
     build_schema_node_tree
 from .xpath_tokens import XPathToken, XPathFunction
@@ -39,15 +39,14 @@ from .schema_proxy import AbstractSchemaProxy
 from .regex import RegexError, translate_pattern, install_unicode_data, unicode_version
 
 __all__ = ['datatypes', 'protocols', 'etree', 'ElementPathError', 'MissingContextError',
-           'UnsupportedFeatureError', 'ElementPathKeyError',
+           'UnsupportedFeatureError', 'ElementPathKeyError',  'ElementPathLocaleError',
            'ElementPathZeroDivisionError', 'ElementPathNameError',
            'ElementPathOverflowError', 'ElementPathRuntimeError', 'ElementPathSyntaxError',
-           'ElementPathTypeError', 'ElementPathValueError', 'ElementPathLocaleError',
-           'XPathContext', 'XPathSchemaContext', 'XPathNode', 'DocumentNode',
-           'ElementNode', 'AttributeNode', 'NamespaceNode', 'CommentNode',
-           'ProcessingInstructionNode', 'TextNode', 'LazyElementNode',
-           'SchemaElementNode', 'get_node_tree', 'build_node_tree',
-           'build_lxml_node_tree', 'build_schema_node_tree', 'XPathToken',
+           'ElementPathTypeError', 'ElementPathValueError', 'XPathContext',
+           'XPathSchemaContext', 'XPathNode', 'AttributeNode', 'NamespaceNode',
+           'CommentNode', 'ProcessingInstructionNode', 'TextNode', 'ElementNode',
+           'LazyElementNode', 'SchemaElementNode', 'DocumentNode', 'get_node_tree',
+           'build_node_tree', 'build_lxml_node_tree', 'build_schema_node_tree', 'XPathToken',
            'XPathFunction', 'XPath1Parser', 'XPath2Parser', 'select', 'iter_select',
            'Selector', 'AbstractSchemaProxy', 'RegexError', 'translate_pattern',
            'install_unicode_data', 'unicode_version']

{elementpath-4.6.0 → elementpath-4.8.0}/elementpath/aliases.py

@@ -30,8 +30,7 @@ InputType = Union[None, T, List[T], Tuple[T, ...]]
 
 if TYPE_CHECKING:
     from elementpath.datatypes import AtomicType, ArithmeticType, NumericType
-    from elementpath.xpath_nodes import ChildNodeType, ParentNodeType
-    from elementpath.tree_builders import RootArgType
+    from elementpath.xpath_nodes import ChildNodeType, ParentNodeType, RootArgType
     from elementpath.xpath_context import ContextType, FunctionArgType, ItemType, \
         ItemArgType, ValueType
     from elementpath.xpath_tokens import XPathParserType, XPathTokenType

{elementpath-4.6.0 → elementpath-4.8.0}/elementpath/compare.py

@@ -18,8 +18,8 @@ from elementpath.protocols import ElementProtocol
 from elementpath.exceptions import xpath_error
 from elementpath.datatypes import UntypedAtomic, AnyURI, AbstractQName
 from elementpath.collations import UNICODE_CODEPOINT_COLLATION, CollationManager
-from elementpath.xpath_nodes import XPathNode, ElementNode, AttributeNode, \
-    NamespaceNode, TextNode, CommentNode, ProcessingInstructionNode, DocumentNode
+from elementpath.xpath_nodes import XPathNode, EtreeElementNode, TextAttributeNode, \
+    NamespaceNode, TextNode, CommentNode, ProcessingInstructionNode, EtreeDocumentNode
 from elementpath.xpath_tokens import XPathToken, XPathFunction, XPathMap, XPathArray
 
 
@@ -28,7 +28,7 @@ def deep_equal(seq1: Iterable[Any],
                collation: Optional[str] = None,
                token: Optional[XPathToken] = None) -> bool:
 
-    etree_node_types = (ElementNode, CommentNode, ProcessingInstructionNode)
+    etree_node_types = (EtreeElementNode, CommentNode, ProcessingInstructionNode)
 
     def etree_deep_equal(e1: ElementProtocol, e2: ElementProtocol) -> bool:
         if cm.ne(e1.tag, e2.tag):
@@ -72,31 +72,31 @@ def deep_equal(seq1: Iterable[Any],
                 return False
             elif isinstance(value1, XPathNode):
                 assert isinstance(value2, XPathNode)
-                if value1.kind != value2.kind:
+                if value1.__class__ != value2.__class__:
                     return False
                 elif isinstance(value1, etree_node_types):
                     assert isinstance(value2, etree_node_types)
-                    if not etree_deep_equal(value1.elem, value2.elem):
+                    if not etree_deep_equal(value1.obj, value2.obj):
                         return False
-                elif isinstance(value1, DocumentNode):
-                    assert isinstance(value2, DocumentNode)
+                elif isinstance(value1, EtreeDocumentNode):
+                    assert isinstance(value2, EtreeDocumentNode)
                     for child1, child2 in zip_longest(value1, value2):
                         if child1 is None or child2 is None:
                             return False
-                        elif child1.kind != child2.kind:
+                        elif child1.__class__ != child2.__class__:
                             return False
                         elif isinstance(child1, etree_node_types):
                             assert isinstance(child2, etree_node_types)
-                            if not etree_deep_equal(child1.elem, child2.elem):
+                            if not etree_deep_equal(child1.obj, child2.obj):
                                 return False
                         elif isinstance(child1, TextNode):
                             assert isinstance(child2, TextNode)
-                            if cm.ne(child1.value, child2.value):
+                            if cm.ne(child1.obj, child2.obj):
                                 return False
 
-                elif cm.ne(value1.value, value2.value):
+                elif cm.ne(value1.obj, value2.obj):
                     return False
-                elif isinstance(value1, AttributeNode):
+                elif isinstance(value1, TextAttributeNode):
                     if cm.ne(value1.name, value2.name):
                         return False
                 elif isinstance(value1, NamespaceNode):
@@ -174,7 +174,7 @@ def deep_compare(obj1: Any,
                  token: Optional[XPathToken] = None) -> int:
 
     msg_tmpl = "Sorting failed, cannot compare {!r} with {!r}"
-    etree_node_types = (ElementNode, CommentNode, ProcessingInstructionNode)
+    etree_node_types = (EtreeElementNode, CommentNode, ProcessingInstructionNode)
     result: int = 0
 
     def iter_object(obj: Any) -> Iterator[Any]:
@@ -244,51 +244,51 @@ def deep_compare(obj1: Any,
                 raise xpath_error('XPTY0004', msg, token=token)
             elif isinstance(value1, XPathNode):
                 assert isinstance(value2, XPathNode)
-                if value1.kind != value2.kind:
+                if value1.__class__ != value2.__class__:
                     msg = f"cannot compare {type(value1)} with {type(value2)}"
                     raise xpath_error('XPTY0004', msg, token=token)
                 elif isinstance(value1, etree_node_types):
                     assert isinstance(value2, etree_node_types)
-                    result = etree_deep_compare(value1.elem, value2.elem)
+                    result = etree_deep_compare(value1.obj, value2.obj)
                     if result:
                         return result
-                elif isinstance(value1, DocumentNode):
-                    assert isinstance(value2, DocumentNode)
+                elif isinstance(value1, EtreeDocumentNode):
+                    assert isinstance(value2, EtreeDocumentNode)
                     for child1, child2 in zip_longest(value1, value2):
                         if child1 is None:
                             return -1
                         elif child2 is None:
                             return 1
-                        elif child1.kind != child2.kind:
+                        elif child1.__class__ != child2.__class__:
                             msg = f"cannot compare {type(child1)} with {type(child2)}"
                             raise xpath_error('XPTY0004', msg, token=token)
                         elif isinstance(child1, etree_node_types):
                             assert isinstance(child2, etree_node_types)
-                            result = etree_deep_compare(child1.elem, child2.elem)
+                            result = etree_deep_compare(child1.obj, child2.obj)
                             if result:
                                 return result
                         elif isinstance(child1, TextNode):
                             assert isinstance(child2, TextNode)
                             result = cm.strcoll(
-                                child1.value.strip(), child2.value.strip()
+                                child1.obj.strip(), child2.obj.strip()
                             )
                             if result:
                                 return result
-                else:
-                    result = cm.strcoll(value1.value, value2.value)
+                elif isinstance(value1, TextNode):
+                    assert isinstance(value2, TextNode)
+                    result = cm.strcoll(value1.obj, value2.obj)
+                    if result:
+                        return result
+                elif isinstance(value1, TextAttributeNode):
+                    assert isinstance(value2, TextAttributeNode)
+                    result = cm.strcoll(value1.name or '', value2.name or '')
+                    if result:
+                        return result
+                elif isinstance(value1, NamespaceNode):
+                    assert isinstance(value2, NamespaceNode)
+                    result = cm.strcoll(value1.prefix or '', value2.prefix or '')
                     if result:
                         return result
-
-                    if isinstance(value1, AttributeNode):
-                        assert isinstance(value2, AttributeNode)
-                        result = cm.strcoll(value1.name or '', value2.name or '')
-                        if result:
-                            return result
-                    elif isinstance(value1, NamespaceNode):
-                        assert isinstance(value2, NamespaceNode)
-                        result = cm.strcoll(value1.prefix or '', value2.prefix or '')
-                        if result:
-                            return result
             else:
                 try:
                     if isinstance(value1, bool):

{elementpath-4.6.0 → elementpath-4.8.0}/elementpath/datatypes/datetime.py

@@ -131,8 +131,15 @@ class AbstractDateTime(AnyAtomicType):
                  tzinfo: Optional[datetime.tzinfo] = None) -> None:
 
         if hour == 24 and minute == second == microsecond == 0:
-            delta = datetime.timedelta(days=1)
             hour = 0
+            if year == 9999 and month == 12 and day == 31:
+                delta = datetime.timedelta(0)
+                year = 10000
+                month = 1
+                day = 1
+            else:
+                delta = datetime.timedelta(days=1)
+                hour = 0
         else:
             delta = datetime.timedelta(0)
 

{elementpath-4.6.0 → elementpath-4.8.0}/elementpath/datatypes/numeric.py

@@ -169,7 +169,7 @@ class Integer(int, AnyAtomicType):
     def __subclasshook__(cls, subclass: Type[Any]) -> bool:
         if cls is Integer:
             return issubclass(subclass, int) and not issubclass(subclass, bool)
-        return NotImplemented
+        return NotImplemented  # type: ignore[no-any-return,unused-ignore]
 
     @classmethod
     def validate(cls, value: object) -> None:

elementpath-4.8.0/elementpath/decoder.py

@@ -0,0 +1,170 @@
+#
+# Copyright (c), 2024, SISSA (International School for Advanced Studies).
+# All rights reserved.
+# This file is distributed under the terms of the MIT License.
+# See the file 'LICENSE' in the root directory of the present
+# distribution, or http://opensource.org/licenses/MIT.
+#
+# @author Davide Brunato <brunato@sissa.it>
+#
+"""
+XSD atomic datatypes subpackage. Includes a class for UntypedAtomic data and
+classes for other XSD built-in types. This subpackage raises only built-in
+exceptions in order to be reusable in other packages.
+"""
+from collections import namedtuple
+from decimal import Decimal
+from functools import lru_cache
+from typing import List, Optional, Type
+
+from elementpath._typing import Callable, Iterator, MutableMapping
+from elementpath.aliases import AnyNsmapType
+from elementpath.datatypes import AtomicType
+from elementpath.protocols import XsdTypeProtocol
+from elementpath.exceptions import xpath_error
+from elementpath.namespaces import XSD_NAMESPACE
+
+import elementpath.datatypes as dt
+
+DecoderType = Callable[[str, AnyNsmapType], AtomicType]
+
+Builder = namedtuple('Builder', 'cls text nsmap', defaults=(None, None))
+
+
+class _Notation(dt.Notation):
+    """An instantiable xs:NOTATION."""
+
+
+# noinspection PyArgumentList
+ATOMIC_BUILDERS: MutableMapping[Optional[str], Builder] = {
+    f'{{{XSD_NAMESPACE}}}untypedAtomic': Builder(dt.UntypedAtomic, '1'),
+    f'{{{XSD_NAMESPACE}}}anyType': Builder(dt.UntypedAtomic, '1'),
+    f'{{{XSD_NAMESPACE}}}anySimpleType': Builder(dt.UntypedAtomic, '1'),
+    f'{{{XSD_NAMESPACE}}}anyAtomicType': Builder(dt.UntypedAtomic, '1'),
+    f'{{{XSD_NAMESPACE}}}boolean': Builder(bool, 'true'),
+    f'{{{XSD_NAMESPACE}}}decimal': Builder(Decimal, '1.0'),
+    f'{{{XSD_NAMESPACE}}}double': Builder(float, '1.0'),
+    f'{{{XSD_NAMESPACE}}}float': Builder(dt.Float10, '1.0'),
+    f'{{{XSD_NAMESPACE}}}string': Builder(str, '  alpha\t'),
+    f'{{{XSD_NAMESPACE}}}date': Builder(dt.Date, '2000-01-01'),
+    f'{{{XSD_NAMESPACE}}}dateTime': Builder(dt.DateTime, '2000-01-01T12:00:00'),
+    f'{{{XSD_NAMESPACE}}}gDay': Builder(dt.GregorianDay, '---31'),
+    f'{{{XSD_NAMESPACE}}}gMonth': Builder(dt.GregorianMonth, '--12'),
+    f'{{{XSD_NAMESPACE}}}gMonthDay': Builder(dt.GregorianMonthDay, '--12-01'),
+    f'{{{XSD_NAMESPACE}}}gYear': Builder(dt.GregorianYear, '1999'),
+    f'{{{XSD_NAMESPACE}}}gYearMonth': Builder(dt.GregorianYearMonth, '1999-09'),
+    f'{{{XSD_NAMESPACE}}}time': Builder(dt.Time, '09:26:54'),
+    f'{{{XSD_NAMESPACE}}}duration': Builder(dt.Duration, 'P1MT1S'),
+    f'{{{XSD_NAMESPACE}}}dayTimeDuration': Builder(dt.DayTimeDuration, 'P1DT1S'),
+    f'{{{XSD_NAMESPACE}}}yearMonthDuration': Builder(dt.YearMonthDuration, 'P1Y1M'),
+    f'{{{XSD_NAMESPACE}}}QName': Builder(dt.QName, 'xs:element'),
+    f'{{{XSD_NAMESPACE}}}NOTATION': Builder(_Notation, 'xs:element'),
+    f'{{{XSD_NAMESPACE}}}anyURI': Builder(dt.AnyURI, 'https://example.com'),
+    f'{{{XSD_NAMESPACE}}}normalizedString': Builder(dt.NormalizedString, ' alpha  '),
+    f'{{{XSD_NAMESPACE}}}token': Builder(dt.XsdToken, 'a token'),
+    f'{{{XSD_NAMESPACE}}}language': Builder(dt.Language, 'en-US'),
+    f'{{{XSD_NAMESPACE}}}Name': Builder(dt.Name, '_a.name::'),
+    f'{{{XSD_NAMESPACE}}}NCName': Builder(dt.NCName, 'nc-name'),
+    f'{{{XSD_NAMESPACE}}}ID': Builder(dt.Id, 'id1'),
+    f'{{{XSD_NAMESPACE}}}IDREF': Builder(dt.Idref, 'id_ref1'),
+    f'{{{XSD_NAMESPACE}}}ENTITY': Builder(dt.Entity, 'entity1'),
+    f'{{{XSD_NAMESPACE}}}NMTOKEN': Builder(dt.NMToken, 'a_token'),
+    f'{{{XSD_NAMESPACE}}}base64Binary': Builder(dt.Base64Binary, 'YWxwaGE='),
+    f'{{{XSD_NAMESPACE}}}hexBinary': Builder(dt.HexBinary, '31'),
+    f'{{{XSD_NAMESPACE}}}dateTimeStamp':
+        Builder(dt.DateTimeStamp.fromstring, '2000-01-01T12:00:00+01:00'),
+    f'{{{XSD_NAMESPACE}}}integer': Builder(dt.Integer, '1'),
+    f'{{{XSD_NAMESPACE}}}long': Builder(dt.Long, '1'),
+    f'{{{XSD_NAMESPACE}}}int': Builder(dt.Int, '1'),
+    f'{{{XSD_NAMESPACE}}}short': Builder(dt.Short, '1'),
+    f'{{{XSD_NAMESPACE}}}byte': Builder(dt.Byte, '1'),
+    f'{{{XSD_NAMESPACE}}}positiveInteger': Builder(dt.PositiveInteger, '1'),
+    f'{{{XSD_NAMESPACE}}}negativeInteger': Builder(dt.NegativeInteger, '-1'),
+    f'{{{XSD_NAMESPACE}}}nonPositiveInteger': Builder(dt.NonPositiveInteger, '0'),
+    f'{{{XSD_NAMESPACE}}}nonNegativeInteger': Builder(dt.NonNegativeInteger, '0'),
+    f'{{{XSD_NAMESPACE}}}unsignedLong': Builder(dt.UnsignedLong, '1'),
+    f'{{{XSD_NAMESPACE}}}unsignedInt': Builder(dt.UnsignedInt, '1'),
+    f'{{{XSD_NAMESPACE}}}unsignedShort': Builder(dt.UnsignedShort, '1'),
+    f'{{{XSD_NAMESPACE}}}unsignedByte': Builder(dt.UnsignedByte, '1'),
+}
+
+
+@lru_cache(maxsize=None)
+def get_builders(xsd_type: XsdTypeProtocol) -> List[Builder]:
+    """
+    Returns a list of atomic builtin XSD types that are in the base type of
+    the XSD type argument.
+    """
+    def iter_builders(root_type: XsdTypeProtocol, depth: int) -> Iterator[Builder]:
+        if depth > 15:
+            return
+        if root_type.name in ATOMIC_BUILDERS:
+            yield ATOMIC_BUILDERS[root_type.name]
+        elif hasattr(root_type, 'member_types'):
+            for member_type in root_type.member_types:
+                yield from iter_builders(member_type, depth + 1)
+
+    if xsd_type.name in ATOMIC_BUILDERS:
+        return [ATOMIC_BUILDERS[xsd_type.name]]
+    elif xsd_type.is_simple() or (simple_type := xsd_type.simple_type) is None:
+        return [builder for builder in iter_builders(xsd_type.root_type, 1)]
+    elif simple_type.name in ATOMIC_BUILDERS:
+        return [ATOMIC_BUILDERS[simple_type.name]]
+    return [builder for builder in iter_builders(simple_type.root_type, 1)]
+
+
+def get_atomic_sequence(xsd_type: Optional[XsdTypeProtocol],
+                        text: object = None,
+                        namespaces: AnyNsmapType = None) -> Iterator[dt.AtomicType]:
+    """Returns a decoder function for atomic values of an XSD type instance."""
+    def decode(value: str) -> dt.AtomicType:
+        if issubclass(cls, (dt.AbstractDateTime, dt.Duration)):
+            return cls.fromstring(value)
+        elif not issubclass(cls, dt.AbstractQName):
+            return cls(value)
+        else:
+            nonlocal namespaces
+            if namespaces is None:
+                namespaces = {'xs': XSD_NAMESPACE}
+            if ':' not in value:
+                return cls(namespaces.get(''), value)
+            else:
+                return cls(namespaces[value.split(':')[0]], value)
+
+    if xsd_type is None:
+        yield dt.UntypedAtomic(text if isinstance(text, str) else '')
+        return
+
+    for k, builder in enumerate(get_builders(xsd_type), start=1):
+        cls: Type[dt.AtomicType] = builder.cls
+
+        _text = text if isinstance(text, str) else builder.text
+        if len(builder) < k and not xsd_type.is_valid(text, namespaces=namespaces):
+            continue
+
+        try:
+            if xsd_type.is_list():
+                for item in _text.split():
+                    yield decode(item)
+            else:
+                yield decode(_text)
+
+        except ValueError as err:
+            raise xpath_error('FORG0001', err, namespaces=namespaces)
+        except ArithmeticError as err:
+            if issubclass(cls, dt.AbstractDateTime):
+                raise xpath_error('FODT0001', err, namespaces=namespaces)
+            elif issubclass(cls, dt.Duration):
+                raise xpath_error('FODT0002', err, namespaces=namespaces)
+            else:
+                raise xpath_error('FOCA0002', err, namespaces=namespaces)
+        else:
+            return
+    else:
+        if hasattr(xsd_type, 'decode'):
+            yield xsd_type.decode(text if isinstance(text, str) else '')
+        else:
+            yield dt.UntypedAtomic(text if isinstance(text, str) else '')
+
+
+__all__ = ['ATOMIC_BUILDERS', 'get_atomic_sequence']

{elementpath-4.6.0 → elementpath-4.8.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']