elementpath 4.4.0__tar.gz → 4.6.0__tar.gz

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

@@ -2,6 +2,19 @@
 CHANGELOG
 *********
 
+`v4.6.0`_ (2024-10-27)
+======================
+* Fix XsdAttributeGroupProtocol
+* Improve Unicode support with installable UnicodeData.txt versions
+* Extend names disambiguation with a fix for issue #78
+* Refactor tree builders to fix document position of tails (issue #79)
+
+`v4.5.0`_ (2024-09-09)
+======================
+* Fix and clean node trees iteration methods (issue #72)
+* Fix missing raw string for '[^\r\n]' (pull request #76)
+* Full and more specific type annotations
+
 `v4.4.0`_ (2024-03-11)
 ======================
 * Improve stand-alone XPath functions builder (issue #70)
@@ -463,3 +476,5 @@ CHANGELOG
 .. _v4.2.1: https://github.com/sissaschool/elementpath/compare/v4.2.0...v4.2.1
 .. _v4.3.0: https://github.com/sissaschool/elementpath/compare/v4.2.1...v4.3.0
 .. _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

{elementpath-4.4.0 → elementpath-4.6.0}/MANIFEST.in

@@ -11,6 +11,7 @@ include mypy.ini
 include doc/*
 
 recursive-include elementpath *
+recursive-include scripts *
 recursive-include tests *
 recursive-exclude tests/.mypy_cache *
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: elementpath
-Version: 4.4.0
+Version: 4.6.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
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development :: Libraries
@@ -32,7 +33,7 @@ Provides-Extra: dev
 Requires-Dist: tox; extra == "dev"
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: lxml; extra == "dev"
-Requires-Dist: xmlschema>=2.0.0; extra == "dev"
+Requires-Dist: xmlschema>=3.3.2; extra == "dev"
 Requires-Dist: Sphinx; extra == "dev"
 Requires-Dist: memory-profiler; extra == "dev"
 Requires-Dist: memray; extra == "dev"
@@ -76,11 +77,13 @@ You can install the package with *pip* in a Python 3.8+ environment::
 
 For using it import the package and apply the selectors on ElementTree nodes:
 
->>> import elementpath
->>> from xml.etree import ElementTree
->>> root = ElementTree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
->>> elementpath.select(root, '/A/B2/*')
-[<Element 'C1' at ...>, <Element 'C2' at ...>, <Element 'C3' at ...>]
+.. code-block:: pycon
+
+    >>> import elementpath
+    >>> from xml.etree import ElementTree
+    >>> root = ElementTree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
+    >>> elementpath.select(root, '/A/B2/*')
+    [<Element 'C1' at ...>, <Element 'C2' at ...>, <Element 'C3' at ...>]
 
 The *select* API provides the standard XPath result format that is a list or an elementary
 datatype's value. If you want only to iterate over results you can use the generator function
@@ -89,52 +92,62 @@ datatype's value. If you want only to iterate over results you can use the gener
 The selectors API works also using XML data trees based on the `lxml.etree <http://lxml.de>`_
 library:
 
->>> import elementpath
->>> import lxml.etree as etree
->>> root = etree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
->>> elementpath.select(root, '/A/B2/*')
-[<Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
+.. code-block:: pycon
+
+    >>> import elementpath
+    >>> import lxml.etree as etree
+    >>> root = etree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
+    >>> elementpath.select(root, '/A/B2/*')
+    [<Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
 
 When you need to apply the same XPath expression to several XML data you can also use the
 *Selector* class, creating an instance and then using it to apply the path on distinct XML
 data:
 
->>> import elementpath
->>> import lxml.etree as etree
->>> selector = elementpath.Selector('/A/*/*')
->>> root = etree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
->>> selector.select(root)
-[<Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
->>> root = etree.XML('<A><B1><C0/></B1><B2><C1/><C2/><C3/></B2></A>')
->>> selector.select(root)
-[<Element C0 at ...>, <Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
+.. code-block:: pycon
+
+    >>> import elementpath
+    >>> import lxml.etree as etree
+    >>> selector = elementpath.Selector('/A/*/*')
+    >>> root = etree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
+    >>> selector.select(root)
+    [<Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
+    >>> root = etree.XML('<A><B1><C0/></B1><B2><C1/><C2/><C3/></B2></A>')
+    >>> selector.select(root)
+    [<Element C0 at ...>, <Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
 
 Public API classes and functions are described into the
 `elementpath manual on the "Read the Docs" site <http://elementpath.readthedocs.io/en/latest/>`_.
 
 For default the XPath 2.0 is used. If you need XPath 1.0 parser provide the *parser* argument:
 
->>> from elementpath import select, XPath1Parser
->>> from xml.etree import ElementTree
->>> root = ElementTree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
->>> select(root, '/A/B2/*', parser=XPath1Parser)
-[<Element 'C1' at ...>, <Element 'C2' at ...>, <Element 'C3' at ...>]
+.. code-block:: pycon
+
+    >>> from elementpath import select, XPath1Parser
+    >>> from xml.etree import ElementTree
+    >>> root = ElementTree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
+    >>> select(root, '/A/B2/*', parser=XPath1Parser)
+    [<Element 'C1' at ...>, <Element 'C2' at ...>, <Element 'C3' at ...>]
 
 For XPath 3.0/3.1 import the parser from *elementpath.xpath3* subpackage, that is not loaded
 for default:
 
->>> from elementpath.xpath3 import XPath3Parser
->>> select(root, 'math:atan(1.0e0)', parser=XPath3Parser)
-0.7853981633974483
+.. code-block:: pycon
+
+    >>> from elementpath.xpath3 import XPath3Parser
+    >>> select(root, 'math:atan(1.0e0)', parser=XPath3Parser)
+    0.7853981633974483
 
 Note: *XPath3Parser* is an alias of *XPath31Parser*.
 
 If you need only XPath 3.0 you can also use a more specific subpackage,
 avoiding the loading of XPath 3.1 implementation:
 
->>> from elementpath.xpath30 import XPath30Parser
->>> select(root, 'math:atan(1.0e0)', parser=XPath30Parser)
-0.7853981633974483
+.. code-block:: pycon
+
+    >>> from elementpath.xpath30 import XPath30Parser
+    >>> select(root, 'math:atan(1.0e0)', parser=XPath30Parser)
+    0.7853981633974483
 
 
 Contributing

{elementpath-4.4.0 → elementpath-4.6.0}/README.rst

@@ -34,11 +34,13 @@ You can install the package with *pip* in a Python 3.8+ environment::
 
 For using it import the package and apply the selectors on ElementTree nodes:
 
->>> import elementpath
->>> from xml.etree import ElementTree
->>> root = ElementTree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
->>> elementpath.select(root, '/A/B2/*')
-[<Element 'C1' at ...>, <Element 'C2' at ...>, <Element 'C3' at ...>]
+.. code-block:: pycon
+
+    >>> import elementpath
+    >>> from xml.etree import ElementTree
+    >>> root = ElementTree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
+    >>> elementpath.select(root, '/A/B2/*')
+    [<Element 'C1' at ...>, <Element 'C2' at ...>, <Element 'C3' at ...>]
 
 The *select* API provides the standard XPath result format that is a list or an elementary
 datatype's value. If you want only to iterate over results you can use the generator function
@@ -47,52 +49,62 @@ datatype's value. If you want only to iterate over results you can use the gener
 The selectors API works also using XML data trees based on the `lxml.etree <http://lxml.de>`_
 library:
 
->>> import elementpath
->>> import lxml.etree as etree
->>> root = etree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
->>> elementpath.select(root, '/A/B2/*')
-[<Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
+.. code-block:: pycon
+
+    >>> import elementpath
+    >>> import lxml.etree as etree
+    >>> root = etree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
+    >>> elementpath.select(root, '/A/B2/*')
+    [<Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
 
 When you need to apply the same XPath expression to several XML data you can also use the
 *Selector* class, creating an instance and then using it to apply the path on distinct XML
 data:
 
->>> import elementpath
->>> import lxml.etree as etree
->>> selector = elementpath.Selector('/A/*/*')
->>> root = etree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
->>> selector.select(root)
-[<Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
->>> root = etree.XML('<A><B1><C0/></B1><B2><C1/><C2/><C3/></B2></A>')
->>> selector.select(root)
-[<Element C0 at ...>, <Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
+.. code-block:: pycon
+
+    >>> import elementpath
+    >>> import lxml.etree as etree
+    >>> selector = elementpath.Selector('/A/*/*')
+    >>> root = etree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
+    >>> selector.select(root)
+    [<Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
+    >>> root = etree.XML('<A><B1><C0/></B1><B2><C1/><C2/><C3/></B2></A>')
+    >>> selector.select(root)
+    [<Element C0 at ...>, <Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
 
 Public API classes and functions are described into the
 `elementpath manual on the "Read the Docs" site <http://elementpath.readthedocs.io/en/latest/>`_.
 
 For default the XPath 2.0 is used. If you need XPath 1.0 parser provide the *parser* argument:
 
->>> from elementpath import select, XPath1Parser
->>> from xml.etree import ElementTree
->>> root = ElementTree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
->>> select(root, '/A/B2/*', parser=XPath1Parser)
-[<Element 'C1' at ...>, <Element 'C2' at ...>, <Element 'C3' at ...>]
+.. code-block:: pycon
+
+    >>> from elementpath import select, XPath1Parser
+    >>> from xml.etree import ElementTree
+    >>> root = ElementTree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
+    >>> select(root, '/A/B2/*', parser=XPath1Parser)
+    [<Element 'C1' at ...>, <Element 'C2' at ...>, <Element 'C3' at ...>]
 
 For XPath 3.0/3.1 import the parser from *elementpath.xpath3* subpackage, that is not loaded
 for default:
 
->>> from elementpath.xpath3 import XPath3Parser
->>> select(root, 'math:atan(1.0e0)', parser=XPath3Parser)
-0.7853981633974483
+.. code-block:: pycon
+
+    >>> from elementpath.xpath3 import XPath3Parser
+    >>> select(root, 'math:atan(1.0e0)', parser=XPath3Parser)
+    0.7853981633974483
 
 Note: *XPath3Parser* is an alias of *XPath31Parser*.
 
 If you need only XPath 3.0 you can also use a more specific subpackage,
 avoiding the loading of XPath 3.1 implementation:
 
->>> from elementpath.xpath30 import XPath30Parser
->>> select(root, 'math:atan(1.0e0)', parser=XPath30Parser)
-0.7853981633974483
+.. code-block:: pycon
+
+    >>> from elementpath.xpath30 import XPath30Parser
+    >>> select(root, 'math:atan(1.0e0)', parser=XPath30Parser)
+    0.7853981633974483
 
 
 Contributing

{elementpath-4.4.0 → elementpath-4.6.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.4'
+version = '4.6'
 # The full version, including alpha/beta/rc tags
-release = '4.4.0'
+release = '4.6.0'
 
 # -- General configuration ---------------------------------------------------
 

{elementpath-4.4.0 → elementpath-4.6.0}/doc/xpath_api.rst

@@ -147,6 +147,8 @@ XPath regular expressions
 =========================
 
 .. autofunction:: elementpath.translate_pattern
+.. autofunction:: elementpath.install_unicode_data
+.. autofunction:: elementpath.unicode_version
 
 
 Exception classes
@@ -154,6 +156,7 @@ Exception classes
 
 .. autoexception:: elementpath.ElementPathError
 .. autoexception:: elementpath.MissingContextError
+.. autoexception:: elementpath.UnsupportedFeatureError
 .. autoexception:: elementpath.RegexError
 .. autoexception:: elementpath.ElementPathLocaleError
 

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

@@ -7,7 +7,7 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
-__version__ = '4.4.0'
+__version__ = '4.6.0'
 __author__ = "Davide Brunato"
 __contact__ = "brunato@sissa.it"
 __copyright__ = "Copyright 2018-2024, SISSA"
@@ -23,7 +23,7 @@ from . import protocols  # Protocols for type annotations
 from .exceptions import ElementPathError, MissingContextError, ElementPathKeyError, \
     ElementPathZeroDivisionError, ElementPathNameError, ElementPathOverflowError, \
     ElementPathRuntimeError, ElementPathSyntaxError, ElementPathTypeError, \
-    ElementPathValueError, ElementPathLocaleError
+    ElementPathValueError, ElementPathLocaleError, UnsupportedFeatureError
 
 from .xpath_context import XPathContext, XPathSchemaContext
 from .xpath_nodes import XPathNode, DocumentNode, ElementNode, AttributeNode, \
@@ -36,10 +36,11 @@ from .xpath1 import XPath1Parser
 from .xpath2 import XPath2Parser
 from .xpath_selectors import select, iter_select, Selector
 from .schema_proxy import AbstractSchemaProxy
-from .regex import RegexError, translate_pattern
+from .regex import RegexError, translate_pattern, install_unicode_data, unicode_version
 
 __all__ = ['datatypes', 'protocols', 'etree', 'ElementPathError', 'MissingContextError',
-           'ElementPathKeyError', 'ElementPathZeroDivisionError', 'ElementPathNameError',
+           'UnsupportedFeatureError', 'ElementPathKeyError',
+           'ElementPathZeroDivisionError', 'ElementPathNameError',
            'ElementPathOverflowError', 'ElementPathRuntimeError', 'ElementPathSyntaxError',
            'ElementPathTypeError', 'ElementPathValueError', 'ElementPathLocaleError',
            'XPathContext', 'XPathSchemaContext', 'XPathNode', 'DocumentNode',
@@ -48,4 +49,5 @@ __all__ = ['datatypes', 'protocols', 'etree', 'ElementPathError', 'MissingContex
            'SchemaElementNode', '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']
+           'Selector', 'AbstractSchemaProxy', 'RegexError', 'translate_pattern',
+           'install_unicode_data', 'unicode_version']

elementpath-4.6.0/elementpath/_typing.py

@@ -0,0 +1,27 @@
+#
+# 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>
+#
+"""
+Version related imports for subscriptable types for type annotations (no builtins).
+"""
+import sys
+
+if sys.version_info < (3, 9):
+    from typing import Callable, Counter, Deque, Iterable, Iterator, \
+        Mapping, Match, MutableMapping, MutableSequence, MutableSet, Pattern, Sequence
+else:
+    from collections import deque as Deque, Counter  # noqa
+    from collections.abc import Callable, Iterable, Iterator, Mapping, MutableMapping, \
+        MutableSequence, MutableSet, Sequence
+    from re import Match, Pattern
+
+
+__all__ = ['Callable', 'Counter', 'Deque', 'Iterable', 'Iterator', 'Match',
+           'Mapping', 'MutableMapping', 'MutableSequence', 'MutableSet',
+           'Pattern', 'Sequence']

elementpath-4.6.0/elementpath/aliases.py

@@ -0,0 +1,43 @@
+#
+# Copyright (c), 2021, 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>
+#
+"""
+Common type hints aliases for elementpath.
+"""
+from typing import Any, List, Optional, NoReturn, Tuple, Type, TYPE_CHECKING, TypeVar, Union
+
+from elementpath._typing import MutableMapping
+
+##
+# 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], ...]]
+
+T = TypeVar('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_context import ContextType, FunctionArgType, ItemType, \
+        ItemArgType, ValueType
+    from elementpath.xpath_tokens import XPathParserType, XPathTokenType
+
+__all__ = ['NamespacesType', 'NsmapType', 'AnyNsmapType', 'NargsType',
+           'ClassCheckType', 'Emptiable', 'SequenceType', 'InputType',
+           'AtomicType', 'ArithmeticType', 'NumericType', 'ChildNodeType',
+           'ParentNodeType', 'RootArgType', 'ContextType', 'FunctionArgType',
+           'ItemType', 'ItemArgType', 'ValueType', 'XPathParserType', 'XPathTokenType']

{elementpath-4.4.0 → elementpath-4.6.0}/elementpath/collations.py

@@ -14,7 +14,7 @@ from types import TracebackType
 from typing import TYPE_CHECKING, Any, Optional, Tuple, Type, Union
 from urllib.parse import urljoin, urlsplit
 
-from .exceptions import xpath_error
+from elementpath.exceptions import xpath_error
 
 if TYPE_CHECKING:
     from .xpath_tokens import XPathToken
@@ -173,8 +173,8 @@ class CollationManager(context_class_base):
     def find(self, a: str, b: str) -> int:
         return self.strxfrm(a).find(self.strxfrm(b))
 
-    def startswith(self, a: str, b: str) -> int:
+    def startswith(self, a: str, b: str) -> bool:
         return self.strxfrm(a).startswith(self.strxfrm(b))
 
-    def endswith(self, a: str, b: str) -> int:
+    def endswith(self, a: str, b: str) -> bool:
         return self.strxfrm(a).endswith(self.strxfrm(b))

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

@@ -11,15 +11,16 @@ import math
 from decimal import Decimal
 from functools import cmp_to_key
 from itertools import zip_longest
-from typing import Any, Callable, Optional, Iterable, Iterator
-
-from .protocols import ElementProtocol
-from .exceptions import xpath_error
-from .datatypes import UntypedAtomic, AnyURI, AbstractQName
-from .collations import UNICODE_CODEPOINT_COLLATION, CollationManager
-from .xpath_nodes import XPathNode, ElementNode, AttributeNode, NamespaceNode, \
-    TextNode, CommentNode, ProcessingInstructionNode, DocumentNode
-from .xpath_tokens import XPathToken, XPathFunction, XPathMap, XPathArray
+from typing import Any, Optional
+
+from elementpath._typing 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_tokens import XPathToken, XPathFunction, XPathMap, XPathArray
 
 
 def deep_equal(seq1: Iterable[Any],

elementpath-4.6.0/elementpath/datatypes/__init__.py

@@ -0,0 +1,61 @@
+#
+# Copyright (c), 2018-2020, 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 decimal import Decimal
+from typing import Union
+
+from .atomic_types import xsd10_atomic_types, xsd11_atomic_types, \
+    AtomicTypeMeta, AnyAtomicType
+from .untyped import UntypedAtomic
+from .qname import AbstractQName, QName, Notation
+from .numeric import Float10, Float, Integer, Int, NegativeInteger, \
+    PositiveInteger, NonNegativeInteger, NonPositiveInteger, Long, \
+    Short, Byte, UnsignedByte, UnsignedInt, UnsignedLong, UnsignedShort
+from .string import NormalizedString, XsdToken, Name, NCName, NMToken, Id, \
+    Idref, Language, Entity
+from .uri import AnyURI
+from .binary import AbstractBinary, Base64Binary, HexBinary
+from .datetime import AbstractDateTime, DateTime10, DateTime, DateTimeStamp, \
+    Date10, Date, GregorianDay, GregorianMonth, GregorianYear, GregorianYear10, \
+    GregorianMonthDay, GregorianYearMonth, GregorianYearMonth10, Time, Timezone, \
+    Duration, DayTimeDuration, YearMonthDuration, OrderedDateTime
+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',
+           'GregorianYear10', 'GregorianYear', 'GregorianYearMonth10', 'GregorianYearMonth',
+           'Timezone', 'Duration', 'YearMonthDuration', 'DayTimeDuration', 'StringProxy',
+           'NormalizedString', 'XsdToken', 'Language', 'Name', 'NCName', 'Id', 'Idref',
+           'Entity', 'NMToken', 'Base64Binary', 'HexBinary', 'Float10', 'Float',
+           'Integer', 'NonPositiveInteger', 'NegativeInteger', 'Long', 'Int', 'Short',
+           'Byte', 'NonNegativeInteger', 'PositiveInteger', 'UnsignedLong', 'UnsignedInt',
+           'UnsignedShort', 'UnsignedByte', 'AnyURI', 'Notation', 'QName', 'BooleanProxy',
+           'DecimalProxy', 'DoubleProxy10', 'DoubleProxy', 'UntypedAtomic', 'AbstractBinary',
+           'AtomicType', 'DatetimeValueType', 'OrderedDateTime', 'AbstractQName',
+           'NumericType', 'ArithmeticType']

{elementpath-4.4.0 → elementpath-4.6.0}/elementpath/datatypes/atomic_types.py

@@ -7,10 +7,12 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
-from abc import ABCMeta
-from typing import Any, Dict, Optional, Pattern, Tuple, Type
+from abc import ABCMeta, abstractmethod
+from typing import Any, Dict, Optional, Tuple, Type
 import re
 
+from elementpath._typing import Pattern
+
 XSD_NAMESPACE = "http://www.w3.org/2001/XMLSchema"
 
 ###
@@ -98,3 +100,7 @@ class AtomicTypeMeta(ABCMeta):
 
 class AnyAtomicType(metaclass=AtomicTypeMeta):
     name = 'anyAtomicType'
+
+    @abstractmethod
+    def __init__(self, value: Any) -> None:
+        raise NotImplementedError()

{elementpath-4.4.0 → elementpath-4.6.0}/elementpath/datatypes/binary.py

@@ -7,12 +7,12 @@
 #
 # @author Davide Brunato <brunato@sissa.it>
 #
+import re
 from abc import abstractmethod
 from typing import Any, Callable, Union
-import re
 import codecs
 
-from ..helpers import collapse_white_spaces
+from elementpath.helpers import collapse_white_spaces
 from .atomic_types import AnyAtomicType
 from .untyped import UntypedAtomic