elementpath 4.7.0__tar.gz → 5.0.0__tar.gz

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

@@ -2,6 +2,22 @@
 CHANGELOG
 *********
 
+`v5.0.0`_ (2025-04-27)
+======================
+* Replace SafeXMLParser with SafeExpatParser
+* Drop compatibility with Python 3.8
+* Restruct node trees with XPathNodeTree backbone
+* Unicode categories fallback with a warning (issue #85)
+* Rewriting decoder module (issue #87)
+* Add extras subpackage for experiment XDM and XPath on Path objects
+
+`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)
@@ -484,3 +500,5 @@ CHANGELOG
 .. _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
+.. _v5.0.0: https://github.com/sissaschool/elementpath/compare/v4.8.0...v5.0.0

{elementpath-4.7.0 → elementpath-5.0.0}/MANIFEST.in

@@ -2,12 +2,9 @@ include LICENSE
 include MANIFEST.in
 include README.rst
 include CHANGELOG.rst
-include setup.py
-include setup.cfg
+include pyproject.toml
 include requirements-dev.txt
 include tox.ini
-include .coveragerc
-include mypy.ini
 include doc/*
 
 recursive-include elementpath *

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

@@ -1,22 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: elementpath
-Version: 4.7.0
+Version: 5.0.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
-Author-email: brunato@sissa.it
-License: MIT
-Keywords: XPath,XPath2,XPath3,XPath31,Pratt-parser,ElementTree,lxml
+Author-email: Davide Brunato <brunato@sissa.it>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sissaschool/elementpath
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -27,19 +23,24 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Text Processing :: Markup :: XML
-Requires-Python: >=3.8
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
 License-File: LICENSE
 Provides-Extra: dev
-Requires-Dist: tox; extra == "dev"
 Requires-Dist: coverage; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
 Requires-Dist: lxml; extra == "dev"
-Requires-Dist: xmlschema>=3.3.2; extra == "dev"
-Requires-Dist: Sphinx; extra == "dev"
-Requires-Dist: memory-profiler; extra == "dev"
+Requires-Dist: lxml-stubs; extra == "dev"
 Requires-Dist: memray; extra == "dev"
-Requires-Dist: flake8; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
-Requires-Dist: lxml-stubs; extra == "dev"
+Requires-Dist: psutil; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: tox; extra == "dev"
+Requires-Dist: xmlschema>=4.0.1; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: readthedocs-sphinx-search; extra == "docs"
+Dynamic: license-file
 
 ***********
 elementpath
@@ -71,7 +72,7 @@ has it's own implementation of XPath 1.0.
 Installation and usage
 ======================
 
-You can install the package with *pip* in a Python 3.8+ environment::
+You can install the package with *pip* in a Python 3.9+ environment::
 
     pip install elementpath
 

{elementpath-4.7.0 → elementpath-5.0.0}/README.rst

@@ -28,7 +28,7 @@ has it's own implementation of XPath 1.0.
 Installation and usage
 ======================
 
-You can install the package with *pip* in a Python 3.8+ environment::
+You can install the package with *pip* in a Python 3.9+ environment::
 
     pip install elementpath
 

{elementpath-4.7.0 → elementpath-5.0.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.7.0 → elementpath-5.0.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.7'
+version = '5.0'
 # The full version, including alpha/beta/rc tags
-release = '4.7.0'
+release = '5.0.0'
 
 # -- General configuration ---------------------------------------------------
 

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

@@ -7,10 +7,10 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
-__version__ = '4.7.0'
+__version__ = '5.0.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.7.0 → elementpath-5.0.0}/elementpath/aliases.py

@@ -10,28 +10,27 @@
 """
 Common type hints aliases for elementpath.
 """
-from typing import Any, List, Optional, NoReturn, Tuple, Type, TYPE_CHECKING, TypeVar, Union
+from typing import Any, Optional, NoReturn, TYPE_CHECKING, TypeVar, Union
 
-from elementpath._typing import MutableMapping
+from collections.abc import MutableMapping
 
 ##
-# Type aliases
+# type aliases
 NamespacesType = MutableMapping[str, str]
 NsmapType = MutableMapping[Optional[str], str]  # compatible with the nsmap of lxml Element
 AnyNsmapType = Union[NamespacesType, NsmapType, None]  # for composition and function arguments
 
-NargsType = Optional[Union[int, Tuple[int, Optional[int]]]]
-ClassCheckType = Union[Type[Any], Tuple[Type[Any], ...]]
+NargsType = Optional[Union[int, tuple[int, Optional[int]]]]
+ClassCheckType = Union[type[Any], tuple[type[Any], ...]]
 
 T = TypeVar('T')
-Emptiable = Union[T, List[NoReturn]]
-SequenceType = Union[T, List[T]]
-InputType = Union[None, T, List[T], Tuple[T, ...]]
+Emptiable = Union[T, list[NoReturn]]
+SequenceType = Union[T, list[T]]
+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.7.0 → elementpath-5.0.0}/elementpath/collations.py

@@ -11,7 +11,7 @@ import locale
 import threading
 from contextlib import AbstractContextManager
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Optional, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 from urllib.parse import urljoin, urlsplit
 
 from elementpath.exceptions import xpath_error
@@ -76,9 +76,9 @@ class CollationManager(context_class_base):
     """
     Context Manager for collations. Provide helper operators as methods.
     """
-    lc_collate: Union[None, str, Tuple[Optional[str], Optional[str]]]
+    lc_collate: Union[None, str, tuple[Optional[str], Optional[str]]]
     fallback: bool = False
-    _current_lc_collate: Optional[Tuple[Optional[str], Optional[str]]] = None
+    _current_lc_collate: Optional[tuple[Optional[str], Optional[str]]] = None
 
     def __init__(self,
                  collation: Optional[str],
@@ -149,7 +149,7 @@ class CollationManager(context_class_base):
 
         return self
 
-    def __exit__(self, exc_type: Optional[Type[BaseException]],
+    def __exit__(self, exc_type: Optional[type[BaseException]],
                  exc_val: Optional[BaseException],
                  exc_tb: Optional[TracebackType]) -> None:
         if self._current_lc_collate is not None:

{elementpath-4.7.0 → elementpath-5.0.0}/elementpath/compare.py

@@ -13,13 +13,13 @@ from functools import cmp_to_key
 from itertools import zip_longest
 from typing import Any, Optional
 
-from elementpath._typing import Callable, Iterable, Iterator
+from collections.abc import Callable, Iterable, Iterator
 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.7.0 → elementpath-5.0.0}/elementpath/datatypes/__init__.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c), 2018-2020, SISSA (International School for Advanced Studies).
+# Copyright (c), 2018-2025, 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
@@ -15,8 +15,7 @@ exceptions in order to be reusable in other packages.
 from decimal import Decimal
 from typing import Union
 
-from .atomic_types import xsd10_atomic_types, xsd11_atomic_types, \
-    AtomicTypeMeta, AnyAtomicType
+from .atomic_types import xsd_atomic_types, AtomicTypeMeta, AnyAtomicType
 from .untyped import UntypedAtomic
 from .qname import AbstractQName, QName, Notation
 from .numeric import Float10, Float, Integer, Int, NegativeInteger, \
@@ -33,22 +32,15 @@ from .datetime import AbstractDateTime, DateTime10, DateTime, DateTimeStamp, \
 from .proxies import BooleanProxy, DecimalProxy, DoubleProxy10, DoubleProxy, \
     StringProxy, NumericProxy, ArithmeticProxy
 
-
-xsd11_atomic_types.update(
-    (k, v) for k, v in xsd10_atomic_types.items() if k not in xsd11_atomic_types
-)
-
 ###
 # Aliases for type annotations
 AtomicType = Union[str, int, float, Decimal, bool, AnyAtomicType]
 NumericType = Union[int, float, Decimal]
 ArithmeticType = Union[NumericType, AbstractDateTime, Duration, UntypedAtomic]
-DatetimeValueType = AbstractDateTime  # keep until v5.0 for backward compatibility
 
-__all__ = ['xsd10_atomic_types', 'xsd11_atomic_types',
-           'AtomicTypeMeta', 'AnyAtomicType', 'NumericProxy', 'ArithmeticProxy',
-           'AbstractDateTime', 'DateTime10', 'DateTime', 'DateTimeStamp', 'Date10',
-           'Date', 'Time', 'GregorianDay', 'GregorianMonth', 'GregorianMonthDay',
+__all__ = ['xsd_atomic_types', 'AtomicTypeMeta', 'AnyAtomicType', 'NumericProxy',
+           'ArithmeticProxy', 'AbstractDateTime', 'DateTime10', 'DateTime', 'DateTimeStamp',
+           'Date10', 'Date', 'Time', 'GregorianDay', 'GregorianMonth', 'GregorianMonthDay',
            'GregorianYear10', 'GregorianYear', 'GregorianYearMonth10', 'GregorianYearMonth',
            'Timezone', 'Duration', 'YearMonthDuration', 'DayTimeDuration', 'StringProxy',
            'NormalizedString', 'XsdToken', 'Language', 'Name', 'NCName', 'Id', 'Idref',
@@ -57,5 +49,4 @@ __all__ = ['xsd10_atomic_types', 'xsd11_atomic_types',
            'Byte', 'NonNegativeInteger', 'PositiveInteger', 'UnsignedLong', 'UnsignedInt',
            'UnsignedShort', 'UnsignedByte', 'AnyURI', 'Notation', 'QName', 'BooleanProxy',
            'DecimalProxy', 'DoubleProxy10', 'DoubleProxy', 'UntypedAtomic', 'AbstractBinary',
-           'AtomicType', 'DatetimeValueType', 'OrderedDateTime', 'AbstractQName',
-           'NumericType', 'ArithmeticType']
+           'AtomicType', 'OrderedDateTime', 'AbstractQName', 'NumericType', 'ArithmeticType']

{elementpath-4.7.0 → elementpath-5.0.0}/elementpath/datatypes/atomic_types.py

@@ -8,11 +8,10 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 from abc import ABCMeta, abstractmethod
-from typing import Any, Dict, Optional, Tuple, Type
+from types import MappingProxyType
+from typing import Any, Optional
 import re
 
-from elementpath._typing import Pattern
-
 XSD_NAMESPACE = "http://www.w3.org/2001/XMLSchema"
 
 ###
@@ -21,11 +20,16 @@ XSD_NAMESPACE = "http://www.w3.org/2001/XMLSchema"
 # into a dictionary. Some classes of XSD primitive types are defined
 # as proxies of basic Python datatypes.
 
-xsd10_atomic_types: Dict[Optional[str], 'AtomicTypeMeta'] = {}
-"""Dictionary of builtin XSD 1.0 atomic types."""
+_xsd_atomic_types: dict[str, dict[Optional[str], 'AtomicTypeMeta']] = {
+    '1.0': {},
+    '1.1': {}
+}
+"""Registry of builtin XSD 1.0/1.1 atomic types."""
 
-xsd11_atomic_types: Dict[Optional[str], 'AtomicTypeMeta'] = {}
-"""Dictionary of builtin XSD 1.1 atomic types."""
+xsd_atomic_types = MappingProxyType({
+    '1.0': MappingProxyType(_xsd_atomic_types['1.0']),
+    '1.1': MappingProxyType(_xsd_atomic_types['1.1']),
+})
 
 
 class AtomicTypeMeta(ABCMeta):
@@ -36,10 +40,8 @@ class AtomicTypeMeta(ABCMeta):
     of XSD atomic types and also the expanded name is added.
     """
     xsd_version: str
-    pattern: Pattern[str]
-    name: Optional[str] = None
 
-    def __new__(mcs, class_name: str, bases: Tuple[Type[Any], ...], dict_: Dict[str, Any]) \
+    def __new__(mcs, class_name: str, bases: tuple[type[Any], ...], dict_: dict[str, Any]) \
             -> 'AtomicTypeMeta':
         try:
             name = dict_['name']
@@ -49,28 +51,26 @@ class AtomicTypeMeta(ABCMeta):
         if name is not None and not isinstance(name, str):
             raise TypeError("attribute 'name' must be a string or None")
 
-        dict_['is_valid'] = classmethod(mcs.is_valid)
-        dict_['invalid_type'] = classmethod(mcs.invalid_type)
-        dict_['invalid_value'] = classmethod(mcs.invalid_value)
         cls = super(AtomicTypeMeta, mcs).__new__(mcs, class_name, bases, dict_)
 
-        # Add missing attributes and methods
-        if not hasattr(cls, 'xsd_version'):
-            cls.xsd_version = '1.0'
-        if not hasattr(cls, 'pattern'):
-            cls.pattern = re.compile(r'^$')
-
-        # Register class with a name
+        # Register ony derived classes with a name
         if name:
-            expanded_name = '{%s}%s' % (XSD_NAMESPACE, name)
-            if cls.xsd_version == '1.0':
-                xsd10_atomic_types[name] = xsd10_atomic_types[expanded_name] = cls
-            else:
-                xsd11_atomic_types[name] = xsd11_atomic_types[expanded_name] = cls
+            for xsd_version, atomic_types in _xsd_atomic_types.items():
+                if cls.xsd_version <= xsd_version and (
+                    name not in atomic_types or atomic_types[name].xsd_version < cls.xsd_version
+                ):
+                    atomic_types[name] = cls
 
         return cls
 
-    def validate(cls: Type[Any], value: object) -> None:
+
+class AnyAtomicType(metaclass=AtomicTypeMeta):
+    name: Optional[str] = 'anyAtomicType'
+    xsd_version: str = '1.0'
+    pattern: re.Pattern[str] = re.compile(r'^$')
+
+    @classmethod
+    def validate(cls, value: object) -> None:
         if isinstance(value, cls):
             return
         elif isinstance(value, str):
@@ -79,7 +79,8 @@ class AtomicTypeMeta(ABCMeta):
         else:
             raise cls.invalid_type(value)
 
-    def is_valid(cls: Type[Any], value: object) -> bool:
+    @classmethod
+    def is_valid(cls, value: object) -> bool:
         try:
             cls.validate(value)
         except (TypeError, ValueError):
@@ -87,20 +88,18 @@ class AtomicTypeMeta(ABCMeta):
         else:
             return True
 
-    def invalid_type(cls: Type[Any], value: object) -> TypeError:
+    @classmethod
+    def invalid_type(cls, value: object) -> TypeError:
         if cls.name:
             return TypeError('invalid type {!r} for xs:{}'.format(type(value), cls.name))
         return TypeError('invalid type {!r} for {!r}'.format(type(value), cls))
 
-    def invalid_value(cls: Type[Any], value: object) -> ValueError:
+    @classmethod
+    def invalid_value(cls, value: object) -> ValueError:
         if cls.name:
             return ValueError('invalid value {!r} for xs:{}'.format(value, cls.name))
         return ValueError('invalid value {!r} for {!r}'.format(value, cls))
 
-
-class AnyAtomicType(metaclass=AtomicTypeMeta):
-    name = 'anyAtomicType'
-
     @abstractmethod
     def __init__(self, value: Any) -> None:
         raise NotImplementedError()