diff --git a/stubs/Markdown/@tests/stubtest_allowlist.txt b/stubs/Markdown/@tests/stubtest_allowlist.txt index 1523b9aa78d0..6ddee2bd9107 100644 --- a/stubs/Markdown/@tests/stubtest_allowlist.txt +++ b/stubs/Markdown/@tests/stubtest_allowlist.txt @@ -1,4 +1,11 @@ -# Deprecated types are infered as functions: +# Implementation detail +markdown.htmlparser.spec + +# *args/**kwargs in implementation properly typed in stubs +markdown.extensions.md_in_html.HTMLExtractorExtra.__init__ +markdown.htmlparser.HTMLExtractor.__init__ + +# Deprecated types are infered as functions markdown.extensions.abbr.AbbrPreprocessor markdown.extensions.abbr.AbbrInlineProcessor markdown.postprocessors.UnescapePostprocessor diff --git a/stubs/Markdown/METADATA.toml b/stubs/Markdown/METADATA.toml index 1e61a2413cbb..082b7e378938 100644 --- a/stubs/Markdown/METADATA.toml +++ b/stubs/Markdown/METADATA.toml @@ -1,2 +1,2 @@ -version = "~=3.10.2" +version = "~=3.11.2" upstream-repository = "https://github.com/Python-Markdown/markdown" diff --git a/stubs/Markdown/markdown/core.pyi b/stubs/Markdown/markdown/core.pyi index 98972399f1ea..dedfceda5b66 100644 --- a/stubs/Markdown/markdown/core.pyi +++ b/stubs/Markdown/markdown/core.pyi @@ -13,6 +13,7 @@ from . import ( treeprocessors as _treeprocessors, ) from .extensions import Extension +from .inlinepatterns import DelimiterProcessor from .util import HtmlStash, Registry __all__ = ["Markdown", "markdown", "markdownFromFile"] @@ -20,21 +21,31 @@ __all__ = ["Markdown", "markdown", "markdownFromFile"] logger: Logger class Markdown: + doc_tag: ClassVar[str] + output_formats: ClassVar[dict[Literal["xhtml", "html"], Callable[[Element], str]]] + + last_run: float + tab_length: int + ESCAPED_CHARS: list[str] + block_level_elements: list[str] + registeredExtensions: list[Extension] + stripTopLevelTags: bool + delimiters: DelimiterProcessor | None + + # Set by build_parser(). preprocessors: Registry[_preprocessors.Preprocessor] + parser: blockparser.BlockParser inlinePatterns: Registry[inlinepatterns.Pattern] treeprocessors: Registry[_treeprocessors.Treeprocessor] postprocessors: Registry[_postprocessors.Postprocessor] - parser: blockparser.BlockParser + + references: dict[str, tuple[str, str]] htmlStash: HtmlStash - output_formats: ClassVar[dict[Literal["xhtml", "html"], Callable[[Element], str]]] + + # Set by set_output_format(). output_format: Literal["xhtml", "html"] serializer: Callable[[Element], str] - tab_length: int - block_level_elements: list[str] - registeredExtensions: list[Extension] - ESCAPED_CHARS: list[str] - doc_tag: ClassVar[str] - stripTopLevelTags: bool + def __init__( self, *, diff --git a/stubs/Markdown/markdown/extensions/__init__.pyi b/stubs/Markdown/markdown/extensions/__init__.pyi index 2ae632654e0f..63e7824d7b51 100644 --- a/stubs/Markdown/markdown/extensions/__init__.pyi +++ b/stubs/Markdown/markdown/extensions/__init__.pyi @@ -3,6 +3,7 @@ from typing import Any from markdown.core import Markdown +# The allowed value types depend on the respective keys. class Extension: config: Mapping[str, list[Any]] def __init__(self, **kwargs: Any) -> None: ... diff --git a/stubs/Markdown/markdown/extensions/attr_list.pyi b/stubs/Markdown/markdown/extensions/attr_list.pyi index 0a837e583259..ba4fb57961d6 100644 --- a/stubs/Markdown/markdown/extensions/attr_list.pyi +++ b/stubs/Markdown/markdown/extensions/attr_list.pyi @@ -1,4 +1,5 @@ from re import Pattern +from typing import Final from xml.etree.ElementTree import Element from markdown.extensions import Extension @@ -8,12 +9,17 @@ def get_attrs_and_remainder(attrs_string: str) -> tuple[list[tuple[str, str]], s def get_attrs(str: str) -> list[tuple[str, str]]: ... def isheader(elem: Element) -> bool: ... +NAME_RE: Final[Pattern[str]] + +def sanitize_name(name: str) -> str: ... + class AttrListTreeprocessor(Treeprocessor): - BASE_RE: str - HEADER_RE: Pattern[str] - BLOCK_RE: Pattern[str] - INLINE_RE: Pattern[str] - NAME_RE: Pattern[str] + BASE_RE: Final[str] + HEADER_RE: Final[Pattern[str]] + BLOCK_RE: Final[Pattern[str]] + INLINE_RE: Final[Pattern[str]] + NAME_RE: Final[Pattern[str]] + def run(self, doc: Element) -> None: ... def assign_attrs(self, elem: Element, attrs_string: str, *, strict: bool = False) -> str: ... def sanitize_name(self, name: str) -> str: ... diff --git a/stubs/Markdown/markdown/extensions/legacy_em.pyi b/stubs/Markdown/markdown/extensions/legacy_em.pyi index 3ea44f44c74f..419f0c375ec7 100644 --- a/stubs/Markdown/markdown/extensions/legacy_em.pyi +++ b/stubs/Markdown/markdown/extensions/legacy_em.pyi @@ -1,11 +1,8 @@ -from markdown.extensions import Extension -from markdown.inlinepatterns import UnderscoreProcessor +from typing import Any -EMPHASIS_RE: str -STRONG_RE: str -STRONG_EM_RE: str +from markdown.extensions import Extension -class LegacyUnderscoreProcessor(UnderscoreProcessor): ... class LegacyEmExtension(Extension): ... -def makeExtension(**kwargs) -> LegacyEmExtension: ... +# kwargs are config key/value pairs, where the value type depends on the key. +def makeExtension(**kwargs: Any) -> LegacyEmExtension: ... diff --git a/stubs/Markdown/markdown/extensions/md_in_html.pyi b/stubs/Markdown/markdown/extensions/md_in_html.pyi index 29cb8f631c11..7dd1d4f7153d 100644 --- a/stubs/Markdown/markdown/extensions/md_in_html.pyi +++ b/stubs/Markdown/markdown/extensions/md_in_html.pyi @@ -1,6 +1,6 @@ from collections.abc import Iterable, Mapping from typing import Literal -from xml.etree.ElementTree import Element, TreeBuilder +from xml.etree.ElementTree import Element from markdown.blockprocessors import BlockProcessor from markdown.extensions import Extension @@ -9,15 +9,15 @@ from markdown.postprocessors import RawHtmlPostprocessor from markdown.preprocessors import Preprocessor class HTMLExtractorExtra(HTMLExtractor): - block_level_tags: set[str] span_tags: set[str] raw_tags: set[str] - block_tags: set[str] - span_and_blocks_tags: set[str] - mdstack: list[str] - treebuilder: TreeBuilder - mdstate: list[Literal["block", "span", "off"] | None] - mdstarted: list[bool] + + @property + def block_level_tags(self) -> set[str]: ... + @property + def block_tags(self) -> set[str]: ... + @property + def span_and_blocks_tags(self) -> set[str]: ... def get_element(self) -> Element: ... def get_state(self, tag: str, attrs: Mapping[str, str]) -> Literal["block", "span", "off"] | None: ... def handle_starttag(self, tag: str, attrs: Iterable[tuple[str, str | None]]) -> None: ... diff --git a/stubs/Markdown/markdown/htmlparser.pyi b/stubs/Markdown/markdown/htmlparser.pyi index b0d95592ef93..be8bb47b0666 100644 --- a/stubs/Markdown/markdown/htmlparser.pyi +++ b/stubs/Markdown/markdown/htmlparser.pyi @@ -1,29 +1,38 @@ import html.parser as htmlparser import re -from _frozen_importlib import ModuleSpec from collections.abc import Sequence +from typing import Final from markdown import Markdown -spec: ModuleSpec -commentclose: re.Pattern[str] -blank_line_re: re.Pattern[str] +commentclose: Final[re.Pattern[str]] +blank_line_re: Final[re.Pattern[str]] +inner_blank_line_re: Final[re.Pattern[str]] +void_tags: Final[frozenset[str]] class HTMLExtractor(htmlparser.HTMLParser): empty_tags: set[str] lineno_start_cache: list[int] md: Markdown - def __init__(self, md: Markdown, *args, **kwargs): ... + + # Set by reset(). inraw: bool intail: bool stack: list[str] + inline_stack: list[str] cleandoc: list[str] + + def __init__(self, md: Markdown, *, convert_charrefs=False, scripting=False) -> None: ... @property def line_offset(self) -> int: ... def at_line_start(self) -> bool: ... def get_endtag_text(self, tag: str) -> str: ... def handle_starttag(self, tag: str, attrs: Sequence[tuple[str, str]]) -> None: ... # type: ignore[override] + def open_inline_tag(self, tag: str) -> None: ... + def close_inline_tag(self, tag: str) -> None: ... + def inline_close_follows(self, text: str) -> bool: ... def handle_empty_tag(self, data: str, is_block: bool) -> None: ... def handle_decl(self, data: str) -> None: ... + def unknown_decl(self, data: str) -> None: ... def parse_bogus_comment(self, i: int, report: int = 0) -> int: ... def get_starttag_text(self) -> str: ... diff --git a/stubs/Markdown/markdown/inlinepatterns.pyi b/stubs/Markdown/markdown/inlinepatterns.pyi index 00ee4b4f0516..7f5ac1711cb1 100644 --- a/stubs/Markdown/markdown/inlinepatterns.pyi +++ b/stubs/Markdown/markdown/inlinepatterns.pyi @@ -1,36 +1,27 @@ import re +from _typeshed import Unused +from collections import deque from collections.abc import Collection -from typing import ClassVar, NamedTuple +from typing import ClassVar, Final, NamedTuple from xml.etree.ElementTree import Element from markdown import util from markdown.core import Markdown -def build_inlinepatterns(md: Markdown, **kwargs) -> util.Registry[Pattern]: ... - -NOIMG: str -BACKTICK_RE: str -ESCAPE_RE: str -EMPHASIS_RE: str -STRONG_RE: str -SMART_STRONG_RE: str -SMART_EMPHASIS_RE: str -SMART_STRONG_EM_RE: str -EM_STRONG_RE: str -EM_STRONG2_RE: str -STRONG_EM_RE: str -STRONG_EM2_RE: str -STRONG_EM3_RE: str -LINK_RE: str -IMAGE_LINK_RE: str -REFERENCE_RE: str -IMAGE_REFERENCE_RE: str -NOT_STRONG_RE: str -AUTOLINK_RE: str -AUTOMAIL_RE: str -HTML_RE: str -ENTITY_RE: str -LINE_BREAK_RE: str +def build_inlinepatterns(md: Markdown, **kwargs: Unused) -> util.Registry[Pattern]: ... + +NOIMG: Final[str] +BACKTICK_RE: Final[str] +ESCAPE_RE: Final[str] +LINK_RE: Final[str] +IMAGE_LINK_RE: Final[str] +REFERENCE_RE: Final[str] +IMAGE_REFERENCE_RE: Final[str] +AUTOLINK_RE: Final[str] +AUTOMAIL_RE: Final[str] +HTML_RE: Final[str] +ENTITY_RE: Final[str] +LINE_BREAK_RE: Final[str] def dequote(string: str) -> str: ... @@ -74,6 +65,8 @@ class BacktickInlineProcessor(InlineProcessor): ESCAPED_BSLASH: str tag: str def __init__(self, pattern: str) -> None: ... + def find_code_spans(self, start: int, text: str) -> tuple[int, int] | None: ... + def handleMatch(self, m: re.Match[str], data: str) -> tuple[Element | str | None, int | None, int | None]: ... # type: ignore[override] class DoubleTagPattern(SimpleTagPattern): ... class DoubleTagInlineProcessor(SimpleTagInlineProcessor): ... @@ -82,15 +75,48 @@ class HtmlInlineProcessor(InlineProcessor): def unescape(self, text: str) -> str: ... def backslash_unescape(self, text: str) -> str: ... -class AsteriskProcessor(InlineProcessor): - PATTERNS: ClassVar[list[EmStrongItem]] - def build_single(self, m: re.Match[str], tag: str, idx: int) -> Element: ... - def build_double(self, m: re.Match[str], tags: str, idx: int) -> Element: ... - def build_double2(self, m: re.Match[str], tags: str, idx: int) -> Element: ... - def parse_sub_patterns(self, data: str, parent: Element, last: Element | None, idx: int) -> None: ... - def build_element(self, m: re.Match[str], builder: str, tags: str, index: int) -> Element: ... +class Delimiter: + stack: deque[tuple[int, int, bool, int]] + tag_count: int + tags: tuple[str, str] + double: bool + single: bool + smart: bool + + token: str + max_size: int + boundary: re.Pattern[str] + bad: re.Pattern[str] + + def __init__(self, token: str, tags: str, smart: bool, double: bool): ... + def reset(self) -> None: ... + +class DelimiterProcessor(InlineProcessor): + SPACE: Final[re.Pattern[str]] + + regions: list[tuple[int, int, int, int, tuple[str, str], int]] + stack: list[tuple[int, int, bool, int]] + tokens: list[str] + delimiters: dict[str, Delimiter] + cache_index: int + cache_pos: int + md: Markdown + safe_mode: bool + pattern: str + compiled_re: re.Pattern[str] -class UnderscoreProcessor(AsteriskProcessor): ... + def __init__(self, token: str, tags: str, md: Markdown, smart: bool = False, double: bool = False) -> None: ... + def add(self, token: str, tags: str, smart: bool = False, double: bool = False) -> None: ... + def remove(self, token: str) -> None: ... + def reset(self) -> None: ... + def increment_next_position(self, start: int, count: int) -> None: ... + def get_cached_result(self, pos: int, data: str) -> tuple[Element, int, int]: ... + def get_match(self, data: str, start: int) -> re.Match[str] | None: ... + def search(self, data: str, start: int) -> re.Match[str] | None: ... + def add_region(self, delim: Delimiter, a: int, b: int, c: int, d: int, size: int) -> None: ... + def handleMatch( # type: ignore[override] + self, m: re.Match[str], data: str + ) -> tuple[Element | None, int | None, int | None]: ... class LinkInlineProcessor(InlineProcessor): RE_LINK: ClassVar[re.Pattern[str]]