elementpath 4.4.0__tar.gz → 4.5.0__tar.gz

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

@@ -2,6 +2,12 @@
 CHANGELOG
 *********
 
+`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 +469,4 @@ 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.4.1: https://github.com/sissaschool/elementpath/compare/v4.4.0...v4.5.0

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: elementpath
-Version: 4.4.0
+Version: 4.5.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
@@ -32,7 +32,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 +76,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 +91,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.5.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.5.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.5'
 # The full version, including alpha/beta/rc tags
-release = '4.4.0'
+release = '4.5.0'
 
 # -- General configuration ---------------------------------------------------
 

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

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

elementpath-4.5.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.5.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.5.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.5.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.5.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.5.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.5.0}/elementpath/datatypes/binary.py

@@ -12,7 +12,7 @@ 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
 

{elementpath-4.4.0 → elementpath-4.5.0}/elementpath/datatypes/datetime.py

@@ -14,9 +14,10 @@ import re
 import datetime
 from calendar import isleap
 from decimal import Decimal, Context
-from typing import cast, Any, Callable, Dict, Optional, Tuple, Union
+from typing import cast, Any, Dict, Optional, Tuple, Type, TypeVar, Union
 
-from ..helpers import MONTH_DAYS_LEAP, MONTH_DAYS, DAYS_IN_4Y, \
+from elementpath._typing import Callable
+from elementpath.helpers import MONTH_DAYS_LEAP, MONTH_DAYS, DAYS_IN_4Y, \
     DAYS_IN_100Y, DAYS_IN_400Y, days_from_common_era, adjust_day, \
     normalized_seconds, months2days, round_number
 from .atomic_types import AnyAtomicType
@@ -112,6 +113,9 @@ class Timezone(datetime.tzinfo):
         raise TypeError("fromutc() argument must be a datetime.datetime instance")
 
 
+_DT = TypeVar('_DT', bound='AbstractDateTime')
+
+
 class AbstractDateTime(AnyAtomicType):
     """
     A class for representing XSD date/time objects. It uses and internal datetime.datetime
@@ -260,8 +264,8 @@ class AbstractDateTime(AnyAtomicType):
         return self._dt.isocalendar()
 
     @classmethod
-    def fromstring(cls, datetime_string: str, tzinfo: Optional[Timezone] = None) \
-            -> 'AbstractDateTime':
+    def fromstring(cls: Type[_DT], datetime_string: str, tzinfo: Optional[Timezone] = None) \
+            -> _DT:
         """
         Creates an XSD date/time instance from a string formatted value.
 
@@ -311,13 +315,13 @@ class AbstractDateTime(AnyAtomicType):
         return cls(tzinfo=tzinfo, **kwargs)
 
     @classmethod
-    def fromdatetime(cls, dt: Union[datetime.datetime, datetime.date, datetime.time],
-                     year: Optional[int] = None) -> 'AbstractDateTime':
+    def fromdatetime(cls: Type[_DT], dt: Union[datetime.datetime, datetime.date, datetime.time],
+                     year: Optional[int] = None) -> _DT:
         """
         Creates an XSD date/time instance from a datetime.datetime/date/time instance.
 
         :param dt: the datetime, date or time instance that stores the XSD Date/Time value.
-        :param year: if an year is provided the created instance refers to it and the \
+        :param year: if a year is provided the created instance refers to it and the \
         possibly present *dt.year* part is ignored.
         :return: an AbstractDateTime concrete subclass instance.
         """
@@ -331,7 +335,7 @@ class AbstractDateTime(AnyAtomicType):
             kwargs['year'] = year
         return cls(**kwargs)
 
-    # Python can't compares offset-naive and offset-aware datetimes
+    # Python can't compare offset-naive and offset-aware datetimes
     def _get_operands(self, other: object) -> Tuple[datetime.datetime, datetime.datetime]:
         if isinstance(other, (self.__class__, datetime.datetime)) or \
                 isinstance(self, other.__class__):
@@ -755,6 +759,9 @@ class Time(AbstractDateTime):
             raise TypeError("wrong type %r for operand %r" % (type(other), other))
 
 
+_D = TypeVar('_D', bound='Duration')
+
+
 class Duration(AnyAtomicType):
     """
     Base class for the XSD duration types.
@@ -817,7 +824,7 @@ class Duration(AnyAtomicType):
         return value
 
     @classmethod
-    def fromstring(cls, text: str) -> 'Duration':
+    def fromstring(cls: Type[_D], text: str) -> _D:
         """
         Creates a Duration instance from a formatted XSD duration string.
 

{elementpath-4.4.0 → elementpath-4.5.0}/elementpath/datatypes/numeric.py

@@ -11,7 +11,7 @@ import re
 import math
 from typing import Any, Optional, SupportsFloat, SupportsInt, Union, Type
 
-from ..helpers import NUMERIC_INF_OR_NAN, INVALID_NUMERIC, collapse_white_spaces
+from elementpath.helpers import NUMERIC_INF_OR_NAN, INVALID_NUMERIC, collapse_white_spaces
 from .atomic_types import AnyAtomicType
 
 
@@ -48,6 +48,9 @@ class Float10(float, AnyAtomicType):
             return super().__new__(cls, -0.0 if str(_value).startswith('-') else 0.0)
         return _value
 
+    def __init__(self, value: Union[str, SupportsFloat]) -> None:
+        float.__init__(self)
+
     def __hash__(self) -> int:
         return super(Float10, self).__hash__()
 
@@ -160,7 +163,7 @@ class Integer(int, AnyAtomicType):
             raise ValueError("value {} is too low for {!r}".format(value, self.__class__))
         elif self.higher_bound is not None and self >= self.higher_bound:
             raise ValueError("value {} is too high for {!r}".format(value, self.__class__))
-        super(Integer, self).__init__()
+        int.__init__(self)
 
     @classmethod
     def __subclasshook__(cls, subclass: Type[Any]) -> bool:

{elementpath-4.4.0 → elementpath-4.5.0}/elementpath/datatypes/proxies.py

@@ -12,7 +12,7 @@ import math
 from decimal import Decimal
 from typing import Any, Union, SupportsFloat
 
-from ..helpers import BOOLEAN_VALUES, collapse_white_spaces, get_double
+from elementpath.helpers import BOOLEAN_VALUES, collapse_white_spaces, get_double
 from .atomic_types import AnyAtomicType
 from .untyped import UntypedAtomic
 from .numeric import Float10, Integer
@@ -45,6 +45,9 @@ class BooleanProxy(AnyAtomicType):
             raise ValueError('invalid value {!r} for xs:{}'.format(value, cls.name))
         return 't' in value or '1' in value
 
+    def __init__(self, value: object) -> None:
+        bool.__init__(self)
+
     @classmethod
     def __subclasshook__(cls, subclass: type) -> bool:
         return issubclass(subclass, bool)
@@ -78,6 +81,9 @@ class DecimalProxy(AnyAtomicType):
             msg = 'invalid value {!r} for xs:{}'
             raise ArithmeticError(msg.format(value, cls.name)) from None
 
+    def __init__(self, value: Any) -> None:
+        pass
+
     @classmethod
     def __subclasshook__(cls, subclass: type) -> bool:
         return issubclass(subclass, (int, Decimal, Integer)) and not issubclass(subclass, bool)
@@ -106,6 +112,9 @@ class DoubleProxy10(AnyAtomicType):
     def __new__(cls, value: Union[SupportsFloat, str]) -> float:  # type: ignore[misc]
         return get_double(value, cls.xsd_version)
 
+    def __init__(self, value: Union[SupportsFloat, str]) -> None:
+        float.__init__(self)
+
     @classmethod
     def __subclasshook__(cls, subclass: type) -> bool:
         return issubclass(subclass, float) and not issubclass(subclass, Float10)
@@ -132,6 +141,9 @@ class StringProxy(AnyAtomicType):
     def __new__(cls, *args: object, **kwargs: object) -> str:  # type: ignore[misc]
         return str(*args, **kwargs)
 
+    def __init__(self, *args: object, **kwargs: object) -> None:
+        str.__init__(self)
+
     @classmethod
     def __subclasshook__(cls, subclass: type) -> bool:
         return issubclass(subclass, str)