elementpath 4.8.0__tar.gz → 5.0.0__tar.gz

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

@@ -2,6 +2,15 @@
 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
@@ -492,3 +501,4 @@ CHANGELOG
 .. _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.8.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.8.0 → elementpath-5.0.0}/PKG-INFO

@@ -1,22 +1,18 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: elementpath
-Version: 4.8.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,29 +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"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
-Dynamic: provides-extra
-Dynamic: requires-python
-Dynamic: summary
+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
@@ -81,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.8.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.8.0 → elementpath-5.0.0}/doc/conf.py

@@ -29,9 +29,9 @@ copyright = '2018-2025, SISSA (International School for Advanced Studies)'
 author = 'Davide Brunato'
 
 # The short X.Y version
-version = '4.8'
+version = '5.0'
 # The full version, including alpha/beta/rc tags
-release = '4.8.0'
+release = '5.0.0'
 
 # -- General configuration ---------------------------------------------------
 

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

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

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

@@ -10,23 +10,23 @@
 """
 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

{elementpath-4.8.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.8.0 → elementpath-5.0.0}/elementpath/compare.py

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

{elementpath-4.8.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.8.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()

{elementpath-4.8.0 → elementpath-5.0.0}/elementpath/datatypes/binary.py

@@ -9,7 +9,7 @@
 #
 import re
 from abc import abstractmethod
-from typing import Any, Callable, Union
+from typing import Union
 import codecs
 
 from elementpath.helpers import collapse_white_spaces
@@ -25,7 +25,6 @@ class AbstractBinary(AnyAtomicType):
     :param ordered: a boolean that enable total ordering for the instance, `False` for default.
     """
     value: bytes
-    invalid_type: Callable[[Any], TypeError]
 
     def __init__(self, value: Union[str, bytes, UntypedAtomic, 'AbstractBinary'],
                  ordered: bool = False) -> None:

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

@@ -8,15 +8,15 @@
 # @author Davide Brunato <brunato@sissa.it>
 #
 from abc import abstractmethod
+from collections.abc import Callable
 import re
 import math
 import operator
 import datetime
 from calendar import isleap
 from decimal import Decimal, Context
-from typing import cast, Any, Dict, Optional, Tuple, Type, TypeVar, Union
+from typing import cast, Any, Optional, TypeVar, Union
 
-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
@@ -63,7 +63,7 @@ class Timezone(datetime.tzinfo):
             raise ValueError("{!r} has not an integral number of minutes".format(duration))
         return cls(datetime.timedelta(seconds=int(duration.seconds)))
 
-    def __getinitargs__(self) -> Tuple[datetime.timedelta]:
+    def __getinitargs__(self) -> tuple[datetime.timedelta]:
         return self.offset,
 
     def __hash__(self) -> int:
@@ -267,11 +267,11 @@ class AbstractDateTime(AnyAtomicType):
     def astimezone(self, tz: Optional[datetime.tzinfo] = None) -> datetime.datetime:
         return self._dt.astimezone(tz)
 
-    def isocalendar(self) -> Tuple[int, int, int]:
+    def isocalendar(self) -> tuple[int, int, int]:
         return self._dt.isocalendar()
 
     @classmethod
-    def fromstring(cls: Type[_DT], datetime_string: str, tzinfo: Optional[Timezone] = None) \
+    def fromstring(cls: type[_DT], datetime_string: str, tzinfo: Optional[Timezone] = None) \
             -> _DT:
         """
         Creates an XSD date/time instance from a string formatted value.
@@ -293,7 +293,7 @@ class AbstractDateTime(AnyAtomicType):
             raise ValueError(msg.format(datetime_string, cls))
 
         match_dict = match.groupdict()
-        kwargs: Dict[str, int] = {
+        kwargs: dict[str, int] = {
             k: int(v) for k, v in match_dict.items() if k != 'tzinfo' and v is not None
         }
 
@@ -322,7 +322,7 @@ class AbstractDateTime(AnyAtomicType):
         return cls(tzinfo=tzinfo, **kwargs)
 
     @classmethod
-    def fromdatetime(cls: Type[_DT], dt: Union[datetime.datetime, datetime.date, datetime.time],
+    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.
@@ -343,7 +343,7 @@ class AbstractDateTime(AnyAtomicType):
         return cls(**kwargs)
 
     # Python can't compare offset-naive and offset-aware datetimes
-    def _get_operands(self, other: object) -> Tuple[datetime.datetime, datetime.datetime]:
+    def _get_operands(self, other: object) -> tuple[datetime.datetime, datetime.datetime]:
         if isinstance(other, (self.__class__, datetime.datetime)) or \
                 isinstance(self, other.__class__):
             dt: datetime.datetime = getattr(other, '_dt', cast(datetime.datetime, other))
@@ -831,7 +831,7 @@ class Duration(AnyAtomicType):
         return value
 
     @classmethod
-    def fromstring(cls: Type[_D], text: str) -> _D:
+    def fromstring(cls: type[_D], text: str) -> _D:
         """
         Creates a Duration instance from a formatted XSD duration string.
 

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

@@ -9,7 +9,7 @@
 #
 import math
 import re
-from typing import Any, Optional, SupportsFloat, SupportsInt, Union, Type
+from typing import Any, Optional, SupportsFloat, SupportsInt, Union
 
 from elementpath.helpers import NUMERIC_INF_OR_NAN, INVALID_NUMERIC, collapse_white_spaces
 from .atomic_types import AnyAtomicType
@@ -166,7 +166,7 @@ class Integer(int, AnyAtomicType):
         int.__init__(self)
 
     @classmethod
-    def __subclasshook__(cls, subclass: Type[Any]) -> bool:
+    def __subclasshook__(cls, subclass: type[Any]) -> bool:
         if cls is Integer:
             return issubclass(subclass, int) and not issubclass(subclass, bool)
         return NotImplemented  # type: ignore[no-any-return,unused-ignore]

{elementpath-4.8.0 → elementpath-5.0.0}/elementpath/datatypes/proxies.py

@@ -21,7 +21,7 @@ from .datetime import AbstractDateTime, Duration
 FloatArgType = Union[SupportsFloat, str, bytes]
 
 ####
-# Type proxies for basic Python datatypes: a proxy class creates
+# type proxies for basic Python datatypes: a proxy class creates
 # and validates its Python datatype and virtual registered types.
 
 
@@ -155,7 +155,7 @@ class StringProxy(AnyAtomicType):
 
 
 ####
-# Type proxies for multiple type-checking in XPath expressions
+# type proxies for multiple type-checking in XPath expressions
 class NumericTypeMeta(type):
     """Metaclass for checking numeric classes and instances."""
 

{elementpath-4.8.0 → elementpath-5.0.0}/elementpath/datatypes/untyped.py

@@ -9,7 +9,7 @@
 #
 import operator
 from decimal import Decimal
-from typing import Any, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 from elementpath.helpers import BOOLEAN_VALUES, get_double
 from .atomic_types import AnyAtomicType
@@ -52,7 +52,7 @@ class UntypedAtomic(AnyAtomicType):
     def __repr__(self) -> str:
         return '%s(%r)' % (self.__class__.__name__, self.value)
 
-    def _get_operands(self, other: Any, force_float: bool = True) -> Tuple[Any, Any]:
+    def _get_operands(self, other: Any, force_float: bool = True) -> tuple[Any, Any]:
         """
         Returns a couple of operands, applying a cast to the instance value based on
         the type of the *other* argument.