⬆️ UPGRADE: Drop support for EOL Python 3.6

.github/workflows/tests.yml

@@ -31,7 +31,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['pypy-3.6', '3.6', '3.7', '3.8', '3.9', '3.10']
+        python-version: ['pypy-3.7', '3.7', '3.8', '3.9', '3.10']
 
     steps:
     - uses: actions/checkout@v2
@@ -126,3 +126,11 @@ jobs:
       with:
         user: __token__
         password: ${{ secrets.PYPI_KEY }}
+
+  allgood:
+    runs-on: ubuntu-latest
+    needs:
+    - pre-commit
+    - tests
+    steps:
+    - run: echo "Great success!"

markdown_it/cli/parse.py

@@ -4,9 +4,11 @@
 
 Parse one or more markdown files, convert each to HTML, and print to stdout.
 """
+from __future__ import annotations
+
 import argparse
+from collections.abc import Iterable, Sequence
 import sys
-from typing import Iterable, Optional, Sequence
 
 from markdown_it import __version__
 from markdown_it.main import MarkdownIt
@@ -15,7 +17,7 @@
 version_str = "markdown-it-py [version {}]".format(__version__)
 
 
-def main(args: Optional[Sequence[str]] = None) -> int:
+def main(args: Sequence[str] | None = None) -> int:
     namespace = parse_args(args)
     if namespace.filenames:
         convert(namespace.filenames)
@@ -63,7 +65,7 @@ def interactive() -> None:
             break
 
 
-def parse_args(args: Optional[Sequence[str]]) -> argparse.Namespace:
+def parse_args(args: Sequence[str] | None) -> argparse.Namespace:
     """Parse input CLI arguments."""
     parser = argparse.ArgumentParser(
         description="Parse one or more markdown files, "

markdown_it/common/normalize_url.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
+from collections.abc import Callable
 import re
-from typing import Callable, Optional
 from urllib.parse import urlparse, urlunparse, quote, unquote  # noqa: F401
 
 import mdurl
@@ -67,7 +69,7 @@ def normalizeLinkText(url: str) -> str:
 GOOD_DATA_RE = re.compile(r"^data:image\/(gif|png|jpeg|webp);")
 
 
-def validateLink(url: str, validator: Optional[Callable] = None) -> bool:
+def validateLink(url: str, validator: Callable | None = None) -> bool:
     """Validate URL link is allowed in output.
 
     This validator can prohibit more than really needed to prevent XSS.

markdown_it/main.py

@@ -1,16 +1,8 @@
+from __future__ import annotations
+
 from contextlib import contextmanager
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generator,
-    Iterable,
-    List,
-    Mapping,
-    MutableMapping,
-    Optional,
-    Union,
-)
+from collections.abc import Callable, Generator, Iterable, Mapping, MutableMapping
+from typing import Any
 
 from . import helpers, presets  # noqa F401
 from .common import normalize_url, utils  # noqa F401
@@ -40,10 +32,10 @@
 class MarkdownIt:
     def __init__(
         self,
-        config: Union[str, Mapping] = "commonmark",
-        options_update: Optional[Mapping] = None,
+        config: str | Mapping = "commonmark",
+        options_update: Mapping | None = None,
         *,
-        renderer_cls: Callable[["MarkdownIt"], RendererProtocol] = RendererHTML,
+        renderer_cls: Callable[[MarkdownIt], RendererProtocol] = RendererHTML,
     ):
         """Main parser class
 
@@ -94,8 +86,8 @@ def set(self, options: MutableMapping) -> None:
         self.options = OptionsDict(options)
 
     def configure(
-        self, presets: Union[str, Mapping], options_update: Optional[Mapping] = None
-    ) -> "MarkdownIt":
+        self, presets: str | Mapping, options_update: Mapping | None = None
+    ) -> MarkdownIt:
         """Batch load of all options and component settings.
         This is an internal method, and you probably will not need it.
         But if you will - see available presets and data structure
@@ -131,7 +123,7 @@ def configure(
 
         return self
 
-    def get_all_rules(self) -> Dict[str, List[str]]:
+    def get_all_rules(self) -> dict[str, list[str]]:
         """Return the names of all active rules."""
         rules = {
             chain: self[chain].ruler.get_all_rules()
@@ -140,7 +132,7 @@ def get_all_rules(self) -> Dict[str, List[str]]:
         rules["inline2"] = self.inline.ruler2.get_all_rules()
         return rules
 
-    def get_active_rules(self) -> Dict[str, List[str]]:
+    def get_active_rules(self) -> dict[str, list[str]]:
         """Return the names of all active rules."""
         rules = {
             chain: self[chain].ruler.get_active_rules()
@@ -150,8 +142,8 @@ def get_active_rules(self) -> Dict[str, List[str]]:
         return rules
 
     def enable(
-        self, names: Union[str, Iterable[str]], ignoreInvalid: bool = False
-    ) -> "MarkdownIt":
+        self, names: str | Iterable[str], ignoreInvalid: bool = False
+    ) -> MarkdownIt:
         """Enable list or rules. (chainable)
 
         :param names: rule name or list of rule names to enable.
@@ -182,8 +174,8 @@ def enable(
         return self
 
     def disable(
-        self, names: Union[str, Iterable[str]], ignoreInvalid: bool = False
-    ) -> "MarkdownIt":
+        self, names: str | Iterable[str], ignoreInvalid: bool = False
+    ) -> MarkdownIt:
         """The same as [[MarkdownIt.enable]], but turn specified rules off. (chainable)
 
         :param names: rule name or list of rule names to disable.
@@ -222,7 +214,7 @@ def add_render_rule(self, name: str, function: Callable, fmt: str = "html") -> N
         if self.renderer.__output__ == fmt:
             self.renderer.rules[name] = function.__get__(self.renderer)  # type: ignore
 
-    def use(self, plugin: Callable, *params, **options) -> "MarkdownIt":
+    def use(self, plugin: Callable, *params, **options) -> MarkdownIt:
         """Load specified plugin with given params into current parser instance. (chainable)
 
         It's just a sugar to call `plugin(md, params)` with curring.
@@ -237,7 +229,7 @@ def func(tokens, idx):
         plugin(self, *params, **options)
         return self
 
-    def parse(self, src: str, env: Optional[MutableMapping] = None) -> List[Token]:
+    def parse(self, src: str, env: MutableMapping | None = None) -> list[Token]:
         """Parse the source string to a token stream
 
         :param src: source string
@@ -260,7 +252,7 @@ def parse(self, src: str, env: Optional[MutableMapping] = None) -> List[Token]:
         self.core.process(state)
         return state.tokens
 
-    def render(self, src: str, env: Optional[MutableMapping] = None) -> Any:
+    def render(self, src: str, env: MutableMapping | None = None) -> Any:
         """Render markdown string into html. It does all magic for you :).
 
         :param src: source string
@@ -274,9 +266,7 @@ def render(self, src: str, env: Optional[MutableMapping] = None) -> Any:
         env = {} if env is None else env
         return self.renderer.render(self.parse(src, env), self.options, env)
 
-    def parseInline(
-        self, src: str, env: Optional[MutableMapping] = None
-    ) -> List[Token]:
+    def parseInline(self, src: str, env: MutableMapping | None = None) -> list[Token]:
         """The same as [[MarkdownIt.parse]] but skip all block rules.
 
         :param src: source string
@@ -296,7 +286,7 @@ def parseInline(
         self.core.process(state)
         return state.tokens
 
-    def renderInline(self, src: str, env: Optional[MutableMapping] = None) -> Any:
+    def renderInline(self, src: str, env: MutableMapping | None = None) -> Any:
         """Similar to [[MarkdownIt.render]] but for single paragraph content.
 
         :param src: source string

markdown_it/parser_block.py

@@ -1,6 +1,7 @@
 """Block-level tokenizer."""
+from __future__ import annotations
+
 import logging
-from typing import List, Optional, Tuple
 
 from .ruler import Ruler
 from .token import Token
@@ -10,7 +11,7 @@
 LOGGER = logging.getLogger(__name__)
 
 
-_rules: List[Tuple] = [
+_rules: list[tuple] = [
     # First 2 params - rule name & source. Secondary array - list of rules,
     # which can be terminated by this one.
     ("table", rules_block.table, ["paragraph", "reference"]),
@@ -97,9 +98,9 @@ def parse(
         src: str,
         md,
         env,
-        outTokens: List[Token],
-        ords: Optional[Tuple[int, ...]] = None,
-    ) -> Optional[List[Token]]:
+        outTokens: list[Token],
+        ords: tuple[int, ...] | None = None,
+    ) -> list[Token] | None:
         """Process input string and push block tokens into `outTokens`."""
         if not src:
             return None

markdown_it/parser_core.py

@@ -4,14 +4,14 @@
  * Top-level rules executor. Glues block/inline parsers and does intermediate
  * transformations.
 """
-from typing import List, Tuple
+from __future__ import annotations
 
 from .ruler import Ruler, RuleFunc
 from .rules_core.state_core import StateCore
 from .rules_core import normalize, block, inline, replace, smartquotes, linkify
 
 
-_rules: List[Tuple[str, RuleFunc]] = [
+_rules: list[tuple[str, RuleFunc]] = [
     ("normalize", normalize),
     ("block", block),
     ("inline", inline),

markdown_it/parser_inline.py

@@ -1,14 +1,14 @@
 """Tokenizes paragraph content.
 """
-from typing import List, Tuple
+from __future__ import annotations
 
 from .ruler import Ruler, RuleFunc
 from .token import Token
 from .rules_inline.state_inline import StateInline
 from . import rules_inline
 
 # Parser rules
-_rules: List[Tuple[str, RuleFunc]] = [
+_rules: list[tuple[str, RuleFunc]] = [
     ("text", rules_inline.text),
     ("newline", rules_inline.newline),
     ("escape", rules_inline.escape),
@@ -22,7 +22,7 @@
     ("entity", rules_inline.entity),
 ]
 
-_rules2: List[Tuple[str, RuleFunc]] = [
+_rules2: list[tuple[str, RuleFunc]] = [
     ("balance_pairs", rules_inline.link_pairs),
     ("strikethrough", rules_inline.strikethrough.postProcess),
     ("emphasis", rules_inline.emphasis.postProcess),
@@ -114,7 +114,7 @@ def tokenize(self, state: StateInline) -> None:
         if state.pending:
             state.pushPending()
 
-    def parse(self, src: str, md, env, tokens: List[Token]) -> List[Token]:
+    def parse(self, src: str, md, env, tokens: list[Token]) -> list[Token]:
         """Process input string and push inline tokens into `tokens`"""
         state = StateInline(src, md, env, tokens)
         self.tokenize(state)

markdown_it/renderer.py

@@ -5,14 +5,11 @@ class Renderer
 copy of rules. Those can be rewritten with ease. Also, you can add new
 rules if you create plugin and adds new token types.
 """
+from __future__ import annotations
+
+from collections.abc import MutableMapping, Sequence
 import inspect
-from typing import (
-    Any,
-    ClassVar,
-    MutableMapping,
-    Optional,
-    Sequence,
-)
+from typing import Any, ClassVar
 
 from .common.utils import unescapeAll, escapeHtml
 from .token import Token
@@ -191,7 +188,7 @@ def renderAttrs(token: Token) -> str:
 
     def renderInlineAsText(
         self,
-        tokens: Optional[Sequence[Token]],
+        tokens: Sequence[Token] | None,
         options: OptionsDict,
         env: MutableMapping,
     ) -> str: