chore: drop support for Python 3.8

Author: Rogdham

.github/workflows/build.yml

@@ -18,13 +18,11 @@ jobs:
     strategy:
       matrix:
         python:
-          - "3.8"
           - "3.9"
           - "3.10"
           - "3.11"
           - "3.12"
           - "3.13"
-          - "pypy-3.8"
           - "pypy-3.9"
           - "pypy-3.10"
     steps:

CHANGELOG.md

@@ -24,6 +24,7 @@ For the purpose of determining breaking changes:
 
 ### :house: Internal
 
+- End of Python 3.8 support
 - Add tests for CPython 3.13
 - Use CPython 3.13 for misc. tests
 - Upgrade dev dependencies

docs/conftest.py

@@ -1,8 +1,8 @@
+from collections.abc import Iterator
 from os import chdir, getcwd
 from pathlib import Path
 import re
 from tempfile import TemporaryDirectory
-from typing import Dict, Iterator
 from unittest.mock import Mock
 
 import pytest
@@ -18,7 +18,7 @@
 
 
 @pytest.fixture(scope="module", autouse=True)
-def _import_pytest(doctest_namespace: Dict[str, object]) -> None:
+def _import_pytest(doctest_namespace: dict[str, object]) -> None:
     doctest_namespace["HandlerTypeHelper"] = HandlerTypeHelper
     doctest_namespace["Parser"] = Parser
     doctest_namespace["XMLElement"] = XMLElement

pyproject.toml

@@ -13,7 +13,6 @@ classifiers = [
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -22,7 +21,7 @@ classifiers = [
     "Topic :: Utilities",
     "Topic :: Text Processing :: Markup :: XML",
 ]
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 dependencies = [
     "defusedxml>=0.7.1",
     "typing-extensions>=4.6.0 ; python_version<'3.12'",
@@ -139,7 +138,7 @@ testpaths = ["docs", "tests"]
 
 [tool.ruff]
 src = ["src"]
-target-version = "py38"
+target-version = "py39"
 
 [tool.ruff.lint]
 select = ["ALL"]

src/bigxml/exceptions.py

@@ -1,4 +1,4 @@
-from typing import Iterable, Iterator
+from collections.abc import Iterable, Iterator
 
 from defusedxml import DefusedXmlException
 from defusedxml.ElementTree import ParseError

src/bigxml/handle_mgr.py

@@ -1,17 +1,6 @@
+from collections.abc import Iterable, Iterator
 import sys
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Tuple,
-    Type,
-    Union,
-    overload,
-)
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union, overload
 
 from bigxml.handler_creator import create_handler
 from bigxml.typing import (
@@ -50,8 +39,8 @@ def iter_from(
         self,
         *handlers: Union[
             str,
-            List[str],
-            Tuple[str, ...],
+            list[str],
+            tuple[str, ...],
         ],
     ) -> Iterator["XMLElement"]: ...
 
@@ -62,8 +51,8 @@ def iter_from(
             Callable[[Union["XMLElement", "XMLText"]], Optional[Iterable[T]]],
             ClassHandlerWithCustomWrapper0[T],
             ClassHandlerWithCustomWrapper1[T],
-            Type[ClassHandlerWithCustomWrapper0[T]],
-            Type[ClassHandlerWithCustomWrapper1[T]],
+            type[ClassHandlerWithCustomWrapper0[T]],
+            type[ClassHandlerWithCustomWrapper1[T]],
         ],
     ) -> Iterator[T]: ...
 
@@ -74,9 +63,9 @@ def iter_from(
             Callable[[Union["XMLElement", "XMLText"]], Optional[Iterable[T]]],
             ClassHandlerWithCustomWrapper0[T],
             ClassHandlerWithCustomWrapper1[T],
-            Type[ClassHandlerWithCustomWrapper0[T]],
-            Type[ClassHandlerWithCustomWrapper1[T]],
-            Type[T],
+            type[ClassHandlerWithCustomWrapper0[T]],
+            type[ClassHandlerWithCustomWrapper1[T]],
+            type[T],
         ],
     ) -> Iterator[T]: ...
 
@@ -87,11 +76,11 @@ def iter_from(
             Callable[[Union["XMLElement", "XMLText"]], Optional[Iterable[T]]],
             ClassHandlerWithCustomWrapper0[T],
             ClassHandlerWithCustomWrapper1[T],
-            Type[ClassHandlerWithCustomWrapper0[T]],
-            Type[ClassHandlerWithCustomWrapper1[T]],
+            type[ClassHandlerWithCustomWrapper0[T]],
+            type[ClassHandlerWithCustomWrapper1[T]],
             str,
-            List[str],
-            Tuple[str, ...],
+            list[str],
+            tuple[str, ...],
         ],
     ) -> Iterator[Union["XMLElement", T]]: ...
 
@@ -102,12 +91,12 @@ def iter_from(
             Callable[[Union["XMLElement", "XMLText"]], Optional[Iterable[T]]],
             ClassHandlerWithCustomWrapper0[T],
             ClassHandlerWithCustomWrapper1[T],
-            Type[ClassHandlerWithCustomWrapper0[T]],
-            Type[ClassHandlerWithCustomWrapper1[T]],
-            Type[T],
+            type[ClassHandlerWithCustomWrapper0[T]],
+            type[ClassHandlerWithCustomWrapper1[T]],
+            type[T],
             str,
-            List[str],
-            Tuple[str, ...],
+            list[str],
+            tuple[str, ...],
         ],
     ) -> Iterator[Union["XMLElement", T]]: ...
 
@@ -135,8 +124,8 @@ def return_from(
         self,
         *handlers: Union[
             str,
-            List[str],
-            Tuple[str, ...],
+            list[str],
+            tuple[str, ...],
         ],
     ) -> Optional["XMLElement"]: ...
 
@@ -147,8 +136,8 @@ def return_from(
             Callable[[Union["XMLElement", "XMLText"]], Optional[Iterable[T]]],
             ClassHandlerWithCustomWrapper0[T],
             ClassHandlerWithCustomWrapper1[T],
-            Type[ClassHandlerWithCustomWrapper0[T]],
-            Type[ClassHandlerWithCustomWrapper1[T]],
+            type[ClassHandlerWithCustomWrapper0[T]],
+            type[ClassHandlerWithCustomWrapper1[T]],
         ],
     ) -> Optional[T]: ...
 
@@ -159,9 +148,9 @@ def return_from(
             Callable[[Union["XMLElement", "XMLText"]], Optional[Iterable[T]]],
             ClassHandlerWithCustomWrapper0[T],
             ClassHandlerWithCustomWrapper1[T],
-            Type[ClassHandlerWithCustomWrapper0[T]],
-            Type[ClassHandlerWithCustomWrapper1[T]],
-            Type[T],
+            type[ClassHandlerWithCustomWrapper0[T]],
+            type[ClassHandlerWithCustomWrapper1[T]],
+            type[T],
         ],
     ) -> Optional[T]: ...
 
@@ -172,11 +161,11 @@ def return_from(
             Callable[[Union["XMLElement", "XMLText"]], Optional[Iterable[T]]],
             ClassHandlerWithCustomWrapper0[T],
             ClassHandlerWithCustomWrapper1[T],
-            Type[ClassHandlerWithCustomWrapper0[T]],
-            Type[ClassHandlerWithCustomWrapper1[T]],
+            type[ClassHandlerWithCustomWrapper0[T]],
+            type[ClassHandlerWithCustomWrapper1[T]],
             str,
-            List[str],
-            Tuple[str, ...],
+            list[str],
+            tuple[str, ...],
         ],
     ) -> Optional[Union["XMLElement", T]]: ...
 
@@ -187,12 +176,12 @@ def return_from(
             Callable[[Union["XMLElement", "XMLText"]], Optional[Iterable[T]]],
             ClassHandlerWithCustomWrapper0[T],
             ClassHandlerWithCustomWrapper1[T],
-            Type[ClassHandlerWithCustomWrapper0[T]],
-            Type[ClassHandlerWithCustomWrapper1[T]],
+            type[ClassHandlerWithCustomWrapper0[T]],
+            type[ClassHandlerWithCustomWrapper1[T]],
             str,
-            List[str],
-            Tuple[str, ...],
-            Type[T],
+            list[str],
+            tuple[str, ...],
+            type[T],
         ],
     ) -> Optional[Union["XMLElement", T]]: ...
 

src/bigxml/handler_creator.py

@@ -1,18 +1,7 @@
+from collections.abc import Iterable, Iterator
 from dataclasses import is_dataclass
 from inspect import getmembers, isclass
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Iterable,
-    Iterator,
-    Optional,
-    Tuple,
-    Type,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union, cast
 import warnings
 
 from bigxml.marks import get_marks, has_marks
@@ -26,7 +15,7 @@
 
 
 def _assert_one_mandatory_param(
-    mandatory_params: Tuple[str, ...], klass: Type[Any], method_name: str
+    mandatory_params: tuple[str, ...], klass: type[Any], method_name: str
 ) -> None:
     if len(mandatory_params) > 1:
         raise TypeError(
@@ -37,7 +26,7 @@ def _assert_one_mandatory_param(
 
 
 def _assert_iterable_or_none(
-    item: object, klass: Type[Any], method_name: str
+    item: object, klass: type[Any], method_name: str
 ) -> Optional[Iterable[object]]:
     if item is None or isinstance(item, Iterable):
         return item
@@ -52,14 +41,14 @@ def _handler_identity(node: T) -> Iterator[T]:
 
 
 class _HandlerTree:
-    def __init__(self, path: Tuple[str, ...] = ()) -> None:
-        self.path: Tuple[str, ...] = path
-        self.children: Dict[str, _HandlerTree] = {}
+    def __init__(self, path: tuple[str, ...] = ()) -> None:
+        self.path: tuple[str, ...] = path
+        self.children: dict[str, _HandlerTree] = {}
         self.handler: Optional[Callable[..., Iterable[object]]] = None
 
     def add_handler(
         self,
-        path: Tuple[str, ...],
+        path: tuple[str, ...],
         handler: object,
         *,
         ignore_direct_marks: bool,
@@ -105,7 +94,7 @@ def add_handler(
 
     def add_handler_callable(
         self,
-        path: Tuple[str, ...],
+        path: tuple[str, ...],
         handler: Callable[..., Iterable[object]],
     ) -> None:
         if self.handler:
@@ -147,7 +136,7 @@ def handle(
 
     @staticmethod
     def _handle_from_class(  # type: ignore[misc]
-        klass: Type[Any], node: Union["XMLElement", "XMLText"]
+        klass: type[Any], node: Union["XMLElement", "XMLText"]
     ) -> Optional[Iterable[object]]:
         # instantiate class
         init_mandatory_params = get_mandatory_params(klass)

src/bigxml/handler_marker.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Generic, Iterable, Optional, Union, cast, overload
+from collections.abc import Iterable
+from typing import Any, Callable, Generic, Optional, Union, cast, overload
 
 from bigxml.marks import add_mark
 from bigxml.nodes import XMLElement, XMLText

src/bigxml/marks.py

@@ -1,17 +1,15 @@
-from typing import Tuple
-
 __ATTR_MARK_NAME = "_xml_handlers_on"
 
 
 def has_marks(obj: object) -> bool:
     return hasattr(obj, __ATTR_MARK_NAME)
 
 
-def get_marks(obj: object) -> Tuple[Tuple[str, ...], ...]:
+def get_marks(obj: object) -> tuple[tuple[str, ...], ...]:
     return getattr(obj, __ATTR_MARK_NAME, ())
 
 
-def add_mark(obj: object, mark: Tuple[str, ...]) -> None:
+def add_mark(obj: object, mark: tuple[str, ...]) -> None:
     marks = get_marks(obj)
     marks += (mark,)
     setattr(obj, __ATTR_MARK_NAME, marks)

src/bigxml/nodes.py

@@ -1,27 +1,16 @@
+from collections.abc import Iterator, Mapping
 from dataclasses import dataclass
-import sys
-from typing import Dict, Iterator, Optional, Tuple, Union
+from typing import Optional, Union
 import warnings
 
 from bigxml.handle_mgr import HandleMgr
 from bigxml.utils import extract_namespace_name
 
-if sys.version_info < (3, 9):  # pragma: no cover
-    from typing import Mapping
-
-    def removeprefix(data: str, prefix: str) -> str:
-        if data.startswith(prefix):
-            return data[len(prefix) :]
-        return data
-
-else:  # pragma: no cover
-    from collections.abc import Mapping
-
 
 class XMLElementAttributes(Mapping[str, str]):
     def __init__(self, attributes: Mapping[str, str]) -> None:
-        self._items: Dict[
-            str, Tuple[Optional[int], str]
+        self._items: dict[
+            str, tuple[Optional[int], str]
         ] = {}  # key -> (alternatives, value)
         self._len = 0
         for key, value in attributes.items():
@@ -53,10 +42,7 @@ def __getitem__(self, key: str) -> str:
     def __iter__(self) -> Iterator[str]:
         for key in self._items:
             if key.startswith("{"):
-                if sys.version_info < (3, 9):  # pragma: no cover
-                    yield removeprefix(key, r"{}")
-                else:  # pragma: no cover
-                    yield key.removeprefix(r"{}")
+                yield key.removeprefix(r"{}")
 
     def __len__(self) -> int:
         return self._len
@@ -81,7 +67,7 @@ def _handler_get_text(node: Union["XMLElement", "XMLText"]) -> Iterator[str]:
 class XMLElement(HandleMgr):
     name: str
     attributes: XMLElementAttributes
-    parents: Tuple["XMLElement", ...]
+    parents: tuple["XMLElement", ...]
     namespace: str = ""
 
     def __post_init__(self) -> None:
@@ -118,7 +104,7 @@ def text(self) -> str:
 @dataclass
 class XMLText:
     text: str
-    parents: Tuple[XMLElement, ...]
+    parents: tuple[XMLElement, ...]
 
     # classname attribute name to be easily switched on with XMLElement
     name = "\0text"  # \0 makes sure it is an invalid element name