[med-svn] [Git][python-team/packages/python-schema-salad][master] 2 commits: synchronize mistune3 patch with upstream.
Michael R. Crusoe (@crusoe)
gitlab at salsa.debian.org
Thu Jan 18 15:33:54 GMT 2024
Michael R. Crusoe pushed to branch master at Debian Python Team / packages / python-schema-salad
Commits:
bdcd4612 by Michael R. Crusoe at 2024-01-18T16:26:33+01:00
synchronize mistune3 patch with upstream.
- - - - -
d29a7a49 by Michael R. Crusoe at 2024-01-18T16:29:00+01:00
Revert "d/rules,d/tests/control: temporarily skip test_multiline_list_entries_without_indention"
This reverts commit 36ca65ba023b1aca1d479a7004d28acb1ced4e06.
- - - - -
4 changed files:
- debian/changelog
- debian/patches/mistune3.patch
- debian/rules
- debian/tests/run-tests
Changes:
=====================================
debian/changelog
=====================================
@@ -9,8 +9,6 @@ python-schema-salad (8.5.20240102191335-1) UNRELEASED; urgency=medium
mistune3.
* d/control: bump python3-mistune dependency to at least version 3,
remove python3-importlib-resources as it isn't needed anymore
- * d/rules,d/tests/control: temporarily skip
- test_multiline_list_entries_without_indention
-- Michael R. Crusoe <crusoe at debian.org> Wed, 03 Jan 2024 14:10:36 +0100
=====================================
debian/patches/mistune3.patch
=====================================
@@ -1,91 +1,272 @@
-From 29f90c7a7541465934a0669edc4a87816b53b6e1 Mon Sep 17 00:00:00 2001
-From: Francis Charette Migneault <francis.charette.migneault at gmail.com>
-Date: Sat, 14 Oct 2023 00:03:42 -0400
-Subject: [PATCH] update makedoc using mistune v3
+From eb6f94f50df314bd665a8aa11e6e47a2cf489675 Mon Sep 17 00:00:00 2001
+From: Francis Charette-Migneault <francis.charette.migneault at gmail.com>
+Date: Thu, 18 Jan 2024 10:24:05 -0500
+Subject: [PATCH] update makedoc using mistune v3 (#787)
+* remove temporary fixme not needed with mistune v3
+* add docstring for our custom escape_html
+* cpp-codegen: appending to this loop's mutable is safe here
+
+Co-authored-by: Michael R. Crusoe <michael.crusoe at gmail.com>
---
- mypy-stubs/mistune/__init__.pyi | 28 -----
- mypy-stubs/mistune/_types.pyi | 5 -
- mypy-stubs/mistune/block_parser.pyi | 147 ------------------------
- mypy-stubs/mistune/inline_parser.pyi | 76 ------------
- mypy-stubs/mistune/markdown.pyi | 35 ------
- mypy-stubs/mistune/plugins/__init__.pyi | 21 ----
- mypy-stubs/mistune/plugins/table.pyi | 17 ---
- mypy-stubs/mistune/renderers.pyi | 109 ------------------
- mypy-stubs/mistune/scanner.pyi | 62 ----------
- mypy-stubs/mistune/util.pyi | 7 --
- requirements.txt | 2 +-
- schema_salad/makedoc.py | 42 ++++---
- setup.py | 2 +-
- 13 files changed, 29 insertions(+), 524 deletions(-)
- delete mode 100644 mypy-stubs/mistune/__init__.pyi
+ mypy-stubs/mistune/__init__.pyi | 57 ++++--
+ mypy-stubs/mistune/__init__.pyi.orig | 26 +++
+ mypy-stubs/mistune/_types.pyi | 5 -
+ mypy-stubs/mistune/block_parser.pyi | 191 +++++-------------
+ mypy-stubs/mistune/block_parser.pyi.orig | 93 +++++++++
+ mypy-stubs/mistune/core.pyi | 85 ++++++++
+ mypy-stubs/mistune/directives/__init__.pyi | 28 +++
+ mypy-stubs/mistune/directives/_base.pyi | 72 +++++++
+ mypy-stubs/mistune/directives/_fenced.pyi | 32 +++
+ mypy-stubs/mistune/directives/_rst.pyi | 25 +++
+ mypy-stubs/mistune/directives/admonition.pyi | 18 ++
+ mypy-stubs/mistune/directives/image.pyi | 21 ++
+ mypy-stubs/mistune/directives/include.pyi | 16 ++
+ mypy-stubs/mistune/directives/toc.pyi | 25 +++
+ mypy-stubs/mistune/helpers.pyi | 30 +++
+ mypy-stubs/mistune/inline_parser.pyi | 112 +++++-----
+ mypy-stubs/mistune/inline_parser.pyi.orig | 29 +++
+ mypy-stubs/mistune/list_parser.pyi | 11 +
+ mypy-stubs/mistune/markdown.pyi | 52 +++--
+ mypy-stubs/mistune/markdown.pyi.orig | 24 +++
+ mypy-stubs/mistune/plugins/__init__.pyi | 23 +--
+ mypy-stubs/mistune/plugins/abbr.pyi | 5 +
+ mypy-stubs/mistune/plugins/def_list.pyi | 5 +
+ mypy-stubs/mistune/plugins/footnotes.pyi | 5 +
+ mypy-stubs/mistune/plugins/formatting.pyi | 9 +
+ mypy-stubs/mistune/plugins/math.pyi | 7 +
+ mypy-stubs/mistune/plugins/ruby.pyi | 18 ++
+ mypy-stubs/mistune/plugins/speedup.pyi | 5 +
+ mypy-stubs/mistune/plugins/spoiler.pyi | 5 +
+ mypy-stubs/mistune/plugins/table.pyi | 20 +-
+ mypy-stubs/mistune/plugins/task_lists.pyi | 5 +
+ mypy-stubs/mistune/plugins/url.pyi | 5 +
+ mypy-stubs/mistune/renderers.pyi | 109 ----------
+ mypy-stubs/mistune/renderers/__init__.pyi | 0
+ mypy-stubs/mistune/renderers/_list.pyi | 7 +
+ mypy-stubs/mistune/renderers/html.pyi | 39 ++++
+ mypy-stubs/mistune/renderers/markdown.pyi | 35 ++++
+ mypy-stubs/mistune/renderers/rst.pyi | 35 ++++
+ .../mistune/{scanner.pyi => scanner.pyi.orig} | 0
+ mypy-stubs/mistune/toc.pyi | 14 ++
+ mypy-stubs/mistune/util.pyi | 14 +-
+ requirements.txt | 2 +-
+ schema_salad/cpp_codegen.py | 2 +-
+ schema_salad/makedoc.py | 168 ++-------------
+ schema_salad/tests/test_makedoc.py | 6 +-
+ setup.py | 2 +-
+ 46 files changed, 939 insertions(+), 558 deletions(-)
+ create mode 100644 mypy-stubs/mistune/__init__.pyi.orig
delete mode 100644 mypy-stubs/mistune/_types.pyi
- delete mode 100644 mypy-stubs/mistune/block_parser.pyi
- delete mode 100644 mypy-stubs/mistune/inline_parser.pyi
- delete mode 100644 mypy-stubs/mistune/markdown.pyi
- delete mode 100644 mypy-stubs/mistune/plugins/__init__.pyi
- delete mode 100644 mypy-stubs/mistune/plugins/table.pyi
+ create mode 100644 mypy-stubs/mistune/block_parser.pyi.orig
+ create mode 100644 mypy-stubs/mistune/core.pyi
+ create mode 100644 mypy-stubs/mistune/directives/__init__.pyi
+ create mode 100644 mypy-stubs/mistune/directives/_base.pyi
+ create mode 100644 mypy-stubs/mistune/directives/_fenced.pyi
+ create mode 100644 mypy-stubs/mistune/directives/_rst.pyi
+ create mode 100644 mypy-stubs/mistune/directives/admonition.pyi
+ create mode 100644 mypy-stubs/mistune/directives/image.pyi
+ create mode 100644 mypy-stubs/mistune/directives/include.pyi
+ create mode 100644 mypy-stubs/mistune/directives/toc.pyi
+ create mode 100644 mypy-stubs/mistune/helpers.pyi
+ create mode 100644 mypy-stubs/mistune/inline_parser.pyi.orig
+ create mode 100644 mypy-stubs/mistune/list_parser.pyi
+ create mode 100644 mypy-stubs/mistune/markdown.pyi.orig
+ create mode 100644 mypy-stubs/mistune/plugins/abbr.pyi
+ create mode 100644 mypy-stubs/mistune/plugins/def_list.pyi
+ create mode 100644 mypy-stubs/mistune/plugins/footnotes.pyi
+ create mode 100644 mypy-stubs/mistune/plugins/formatting.pyi
+ create mode 100644 mypy-stubs/mistune/plugins/math.pyi
+ create mode 100644 mypy-stubs/mistune/plugins/ruby.pyi
+ create mode 100644 mypy-stubs/mistune/plugins/speedup.pyi
+ create mode 100644 mypy-stubs/mistune/plugins/spoiler.pyi
+ create mode 100644 mypy-stubs/mistune/plugins/task_lists.pyi
+ create mode 100644 mypy-stubs/mistune/plugins/url.pyi
delete mode 100644 mypy-stubs/mistune/renderers.pyi
- delete mode 100644 mypy-stubs/mistune/scanner.pyi
- delete mode 100644 mypy-stubs/mistune/util.pyi
+ create mode 100644 mypy-stubs/mistune/renderers/__init__.pyi
+ create mode 100644 mypy-stubs/mistune/renderers/_list.pyi
+ create mode 100644 mypy-stubs/mistune/renderers/html.pyi
+ create mode 100644 mypy-stubs/mistune/renderers/markdown.pyi
+ create mode 100644 mypy-stubs/mistune/renderers/rst.pyi
+ rename mypy-stubs/mistune/{scanner.pyi => scanner.pyi.orig} (100%)
+ create mode 100644 mypy-stubs/mistune/toc.pyi
--- python-schema-salad.orig/mypy-stubs/mistune/__init__.pyi
+++ python-schema-salad/mypy-stubs/mistune/__init__.pyi
-@@ -1,28 +1,26 @@
+@@ -1,28 +1,51 @@
-from typing import Iterable, Optional, Union
-+from typing import Iterable, Optional, Union, Any
++from typing import Any, Dict, Iterable, List, Optional, Union
- from mistune._types import *
+-from mistune._types import *
-from mistune.inline_parser import RendererT
-from mistune.markdown import Markdown, ParseHook, RenderHook
-from mistune.plugins import Plugin, PluginName
-from mistune.renderers import BaseRenderer, DataT, HTMLRenderer, HTMLType
-+from mistune.markdown import Markdown
-+from mistune.core import BaseRenderer
-+from mistune.renderers.html import HTMLRenderer
from typing_extensions import Literal
-html: Markdown[HTMLType, HTMLRenderer]
-+html: Markdown
++from .block_parser import BlockParser as BlockParser
++from .core import BaseRenderer as BaseRenderer
++from .core import BlockState as BlockState
++from .core import InlineState as InlineState
++from .inline_parser import InlineParser as InlineParser
++from .markdown import Markdown as Markdown
++from .plugins import PluginRef
++from .renderers.html import HTMLRenderer as HTMLRenderer
++from .util import escape as escape
++from .util import escape_url as escape_url
++from .util import safe_entity as safe_entity
++from .util import unikey as unikey
-RendererRef = Union[Literal["html", "ast"], BaseRenderer[DataT]]
-PluginRef = Union[PluginName, Plugin] # reference to register a plugin
++__all__ = [
++ "Markdown",
++ "HTMLRenderer",
++ "BlockParser",
++ "BlockState",
++ "BaseRenderer",
++ "InlineParser",
++ "InlineState",
++ "escape",
++ "escape_url",
++ "safe_entity",
++ "unikey",
++ "html",
++ "create_markdown",
++ "markdown",
++]
++
+RendererRef = Union[Literal["html", "ast"], BaseRenderer]
def create_markdown(
- escape: bool = False,
+- escape: bool = False,
++ escape: bool = True,
hard_wrap: bool = False,
- renderer: Optional[RendererRef[DataT]] = None,
-- plugins: Optional[Iterable[PluginRef]] = None,
++ renderer: Optional[RendererRef] = "html",
+ plugins: Optional[Iterable[PluginRef]] = None,
-) -> Markdown[DataT, RendererT]: ...
-+ renderer: Optional[RendererRef] = None,
-+ plugins: Optional[Iterable[Any]] = None,
+) -> Markdown: ...
++
++html: Markdown
++
def markdown(
text: str,
escape: bool = True,
- renderer: Optional[BaseRenderer[DataT]] = None,
- plugins: Optional[Iterable[PluginRef]] = None,
-+ renderer: Optional[BaseRenderer] = None,
+-) -> str: ...
+-
+-__version__: str
++ renderer: Optional[RendererRef] = "html",
+ plugins: Optional[Iterable[Any]] = None,
- ) -> str: ...
-
- __version__: str
++) -> Union[str, List[Dict[str, Any]]]: ...
+--- python-schema-salad.orig/mypy-stubs/mistune/_types.pyi
++++ /dev/null
+@@ -1,5 +0,0 @@
+-from typing import Any, Dict, List
+-
+-# type aliases shared across modules
+-State = Dict[str, Any] # extra options that work with a given 'ParsedType'
+-Tokens = List[str]
--- python-schema-salad.orig/mypy-stubs/mistune/block_parser.pyi
+++ python-schema-salad/mypy-stubs/mistune/block_parser.pyi
-@@ -14,8 +14,6 @@
- )
+@@ -1,147 +1,50 @@
+-import sys
+-from typing import (
+- Any,
+- ClassVar,
+- Iterator,
+- List,
+- Match,
+- Optional,
+- Pattern,
+- Tuple,
+- Type,
+- TypeVar,
+- Union,
+-)
++from typing import ClassVar, Dict, Iterable, List, Match, Optional, Pattern, Tuple
- from mistune._types import State, Tokens
+-from mistune._types import State, Tokens
-from mistune.inline_parser import InlineParser, RendererT
-from mistune.renderers import DataT
- from mistune.scanner import Matcher, ScannerParser
- from typing_extensions import Literal, NotRequired, Required, TypeAlias, TypedDict
-
-@@ -91,57 +89,5 @@
- ParsedBlockListItem = ParsedBlock
- ParsedBlockParagraph = ParsedBlock
-
+-from mistune.scanner import Matcher, ScannerParser
+-from typing_extensions import Literal, NotRequired, Required, TypeAlias, TypedDict
+-
+-ParsedBlockType = Literal[
+- # base block parsers
+- "heading",
+- "newline",
+- "thematic_break",
+- "block_code",
+- "block_html",
+- "block_quote",
+- "block_text",
+- "list",
+- "list_item",
+- "paragraph",
+- # plugin 'table'
+- "table",
+- "table_head",
+- "table_body",
+- "table_cell",
+- "table_row",
+- # plugin 'url'
+- "url",
+-]
+-_ParsedBlock: TypeAlias = "ParsedBlock"
+-if sys.version_info >= (3, 7):
+- ParsedTypeT = TypeVar("ParsedTypeT")
+- ParsedBlock = TypedDict(
+- "ParsedBlock",
+- {
+- "type": Required[ParsedTypeT],
+- "blank": NotRequired[bool],
+- "raw": NotRequired[str],
+- "text": NotRequired[str],
+- "params": NotRequired[Tuple[Union[int, str], ...]],
+- "children": NotRequired[List[_ParsedBlock]],
+- },
+- total=False,
+- )
+- ParsedBlockHeading = ParsedBlock[Literal["heading"]]
+- ParsedBlockNewline = ParsedBlock[Literal["newline"]]
+- ParsedBlockThematicBreak = ParsedBlock[Literal["thematic_break"]]
+- ParsedBlockBlockCode = ParsedBlock[Literal["block_code"]]
+- ParsedBlockBlockHTML = ParsedBlock[Literal["block_html"]]
+- ParsedBlockBlockQuote = ParsedBlock[Literal["block_quote"]]
+- ParsedBlockBlockText = ParsedBlock[Literal["block_text"]]
+- ParsedBlockList = ParsedBlock[Literal["list"]]
+- ParsedBlockListItem = ParsedBlock[Literal["list_item"]]
+- ParsedBlockParagraph = ParsedBlock[Literal["paragraph"]]
+-else: # python 3.6 # no TypedDict+Generic support with TypeVar
+- ParsedBlock = TypedDict(
+- "ParsedBlock",
+- {
+- # best we can do is define an 'AnyOf' allowed literals
+- # we cannot provide explicitly which literal is returned each time
+- "type": Required[ParsedBlockType],
+- "blank": NotRequired[bool],
+- "raw": NotRequired[str],
+- "text": NotRequired[str],
+- "params": NotRequired[Tuple[Union[int, str], ...]],
+- "children": NotRequired[List[_ParsedBlock]],
+- },
+- total=False,
+- )
+- ParsedBlockHeading = ParsedBlock
+- ParsedBlockNewline = ParsedBlock
+- ParsedBlockThematicBreak = ParsedBlock
+- ParsedBlockBlockCode = ParsedBlock
+- ParsedBlockBlockHTML = ParsedBlock
+- ParsedBlockBlockQuote = ParsedBlock
+- ParsedBlockBlockText = ParsedBlock
+- ParsedBlockList = ParsedBlock
+- ParsedBlockListItem = ParsedBlock
+- ParsedBlockParagraph = ParsedBlock
+-
-class BlockParser(ScannerParser):
- NEWLINE: Pattern[str]
- DEF_LINK: Pattern[str]
@@ -101,7 +282,31 @@ Subject: [PATCH] update makedoc using mistune v3
- BLOCK_QUOTE_MAX_DEPTH: ClassVar[int]
-
- scanner_cls: ClassVar[Type[Matcher]] = Matcher
-- block_quote_rules: List[str]
++from .core import BlockState as BlockState
++from .core import Parser as Parser
++from .helpers import BLOCK_TAGS as BLOCK_TAGS
++from .helpers import HTML_ATTRIBUTES as HTML_ATTRIBUTES
++from .helpers import HTML_TAGNAME as HTML_TAGNAME
++from .helpers import LINK_LABEL as LINK_LABEL
++from .helpers import PRE_TAGS as PRE_TAGS
++from .helpers import parse_link_href as parse_link_href
++from .helpers import parse_link_title as parse_link_title
++from .helpers import unescape_char as unescape_char
++from .list_parser import LIST_PATTERN as LIST_PATTERN
++from .list_parser import parse_list as parse_list
++from .util import escape_url as escape_url
++from .util import expand_leading_tab as expand_leading_tab
++from .util import expand_tab as expand_tab
++from .util import unikey as unikey
++
++class BlockParser(Parser[BlockState]):
++ state_cls = BlockState
++ BLANK_LINE: Pattern[str]
++ RAW_HTML: str
++ BLOCK_HTML: str
++ SPECIFICATION: ClassVar[Dict[str, str]]
++ DEFAULT_RULES: ClassVar[Iterable[str]]
+ block_quote_rules: List[str]
- list_rules = List[str]
-
- def __init__(self) -> None: ...
@@ -138,26 +343,448 @@ Subject: [PATCH] update makedoc using mistune v3
- self, tokens: Tokens, inline: InlineParser[RendererT], state: State
- ) -> Iterator[DataT]: ...
-
- def cleanup_lines(s: str) -> str: ...
- def expand_leading_tab(text: str) -> str: ...
+-def cleanup_lines(s: str) -> str: ...
+-def expand_leading_tab(text: str) -> str: ...
++ list_rules: List[str]
++ max_nested_level: int
++ def __init__(
++ self,
++ block_quote_rules: Optional[List[str]] = None,
++ list_rules: Optional[List[str]] = None,
++ max_nested_level: int = 6,
++ ) -> None: ...
++ def parse_blank_line(self, m: Match[str], state: BlockState) -> int: ...
++ def parse_thematic_break(self, m: Match[str], state: BlockState) -> int: ...
++ def parse_indent_code(self, m: Match[str], state: BlockState) -> int: ...
++ def parse_fenced_code(self, m: Match[str], state: BlockState) -> Optional[int]: ...
++ def parse_atx_heading(self, m: Match[str], state: BlockState) -> int: ...
++ def parse_setex_heading(self, m: Match[str], state: BlockState) -> Optional[int]: ...
++ def parse_ref_link(self, m: Match[str], state: BlockState) -> Optional[int]: ...
++ def extract_block_quote(
++ self, m: Match[str], state: BlockState
++ ) -> Tuple[str, Optional[int]]: ...
++ def parse_block_quote(self, m: Match[str], state: BlockState) -> int: ...
++ def parse_list(self, m: Match[str], state: BlockState) -> int: ...
++ def parse_block_html(self, m: Match[str], state: BlockState) -> Optional[int]: ...
++ def parse_raw_html(self, m: Match[str], state: BlockState) -> Optional[int]: ...
++ def parse(self, state: BlockState, rules: Optional[List[str]] = None) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/core.pyi
+@@ -0,0 +1,85 @@
++import re
++from collections.abc import Generator as Generator
++from typing import (
++ Any,
++ Callable,
++ ClassVar,
++ Dict,
++ Generic,
++ Iterable,
++ List,
++ Match,
++ MutableMapping,
++ Optional,
++ Pattern,
++ Type,
++ TypeVar,
++ Union,
++)
++
++from typing_extensions import Self
++
++class BlockState:
++ src: str
++ tokens: List[Dict[str, Any]]
++ cursor: int
++ cursor_max: int
++ list_tight: bool
++ parent: Any
++ env: MutableMapping[str, Any]
++ def __init__(self, parent: Optional[Any] = None) -> None: ...
++ def child_state(self, src: str) -> BlockState: ...
++ def process(self, src: str) -> None: ...
++ def find_line_end(self) -> int: ...
++ def get_text(self, end_pos: int) -> str: ...
++ def last_token(self) -> Any: ...
++ def prepend_token(self, token: Dict[str, Any]) -> None: ...
++ def append_token(self, token: Dict[str, Any]) -> None: ...
++ def add_paragraph(self, text: str) -> None: ...
++ def append_paragraph(self) -> Optional[int]: ...
++ def depth(self) -> int: ...
++
++class InlineState:
++ env: MutableMapping[str, Any]
++ src: str
++ tokens: List[Dict[str, Any]]
++ in_image: bool
++ in_link: bool
++ in_emphasis: bool
++ in_strong: bool
++ def __init__(self, env: MutableMapping[str, Any]) -> None: ...
++ def prepend_token(self, token: Dict[str, Any]) -> None: ...
++ def append_token(self, token: Dict[str, Any]) -> None: ...
++ def copy(self) -> InlineState: ...
++
++ST = TypeVar("ST", InlineState, BlockState)
++
++class Parser(Generic[ST]):
++ sc_flag: re._FlagsType
++ state_cls: Type[ST]
++ SPECIFICATION: ClassVar[Dict[str, str]]
++ DEFAULT_RULES: ClassVar[Iterable[str]]
++ specification: Dict[str, str]
++ rules: Iterable[str]
++ def __init__(self) -> None: ...
++ def compile_sc(self, rules: Optional[List[str]] = None) -> Pattern[str]: ...
++ def register(
++ self,
++ name: str,
++ pattern: Union[str, None],
++ func: Callable[[Self, Match[str], ST], Optional[int]],
++ before: Optional[str] = None,
++ ) -> None: ...
++ def register_rule(self, name: str, pattern: str, func: Any) -> None: ...
++ @staticmethod
++ def insert_rule(rules: List[str], name: str, before: Optional[str] = None) -> None: ...
++ def parse_method(self, m: Match[str], state: ST) -> Optional[int]: ...
++
++class BaseRenderer:
++ NAME: ClassVar[str]
++ def __init__(self) -> None: ...
++ def register(self, name: str, method: Callable[..., str]) -> None: ...
++ def render_token(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def iter_tokens(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> Iterable[str]: ...
++ def render_tokens(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> str: ...
++ def __call__(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> str: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/directives/__init__.pyi
+@@ -0,0 +1,28 @@
++from typing import List
++
++from ._base import BaseDirective as BaseDirective
++from ._base import DirectiveParser as DirectiveParser
++from ._base import DirectivePlugin as DirectivePlugin
++from ._fenced import FencedDirective as FencedDirective
++from ._rst import RSTDirective as RSTDirective
++from .admonition import Admonition as Admonition
++from .image import Figure as Figure
++from .image import Image as Image
++from .include import Include as Include
++from .toc import TableOfContents as TableOfContents
++
++__all__ = [
++ "DirectiveParser",
++ "BaseDirective",
++ "DirectivePlugin",
++ "RSTDirective",
++ "FencedDirective",
++ "Admonition",
++ "TableOfContents",
++ "Include",
++ "Image",
++ "Figure",
++]
++
++class RstDirective(RSTDirective):
++ def __init__(self, plugins: List[DirectivePlugin]) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/directives/_base.pyi
+@@ -0,0 +1,72 @@
++import abc
++from abc import ABCMeta, abstractmethod
++from typing import (
++ Any,
++ Callable,
++ Dict,
++ Iterable,
++ List,
++ Match,
++ Optional,
++ Tuple,
++ Type,
++ Union,
++)
++
++from ..block_parser import BlockParser as BlockParser
++from ..core import BlockState as BlockState
++from ..markdown import Markdown as Markdown
++
++class DirectiveParser(ABCMeta, metaclass=abc.ABCMeta):
++ name: str
++ @staticmethod
++ @abstractmethod
++ def parse_type(m: Match[str]) -> str: ...
++ @staticmethod
++ @abstractmethod
++ def parse_title(m: Match[str]) -> str: ...
++ @staticmethod
++ @abstractmethod
++ def parse_content(m: Match[str]) -> str: ...
++ @classmethod
++ def parse_tokens(
++ cls, block: BlockParser, text: str, state: BlockState
++ ) -> Iterable[Dict[str, Any]]: ...
++ @staticmethod
++ def parse_options(m: Match[str]) -> List[Tuple[str, str]]: ...
++
++class BaseDirective(metaclass=ABCMeta):
++ parser: Type[DirectiveParser]
++ directive_pattern: Optional[str]
++ def __init__(self, plugins: List["DirectivePlugin"]) -> None: ...
++ def register(
++ self,
++ name: str,
++ fn: Callable[
++ [BlockParser, Match[str], BlockState], Union[Dict[str, Any], List[Dict[str, Any]]]
++ ],
++ ) -> None: ...
++ def parse_method(
++ self, block: BlockParser, m: Match[str], state: BlockState
++ ) -> Union[Dict[str, Any], List[Dict[str, Any]]]: ...
++ @abstractmethod
++ def parse_directive(
++ self, block: BlockParser, m: Match[str], state: BlockState
++ ) -> Optional[int]: ...
++ def register_block_parser(self, md: Markdown, before: Optional[str] = None) -> None: ...
++ def __call__(self, markdown: Markdown) -> None: ...
++
++class DirectivePlugin:
++ parser: Type[DirectiveParser]
++ def __init__(self) -> None: ...
++ def parse_options(self, m: Match[str]) -> List[Tuple[str, str]]: ...
++ def parse_type(self, m: Match[str]) -> str: ...
++ def parse_title(self, m: Match[str]) -> str: ...
++ def parse_content(self, m: Match[str]) -> str: ...
++ def parse_tokens(
++ self, block: BlockParser, text: str, state: BlockState
++ ) -> Iterable[Dict[str, Any]]: ...
++ def parse(
++ self, block: BlockParser, m: Match[str], state: BlockState
++ ) -> Union[Dict[str, Any], List[Dict[str, Any]]]: ...
++ def __call__(self, directive: BaseDirective, md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/directives/_fenced.pyi
+@@ -0,0 +1,32 @@
++from typing import List, Match, Optional
++
++from _typeshed import Incomplete
++
++from ..block_parser import BlockParser
++from ..core import BlockState
++from ..markdown import Markdown
++from ._base import BaseDirective, DirectiveParser, DirectivePlugin
++
++__all__ = ["FencedDirective"]
++
++class FencedParser(DirectiveParser):
++ name: str
++ @staticmethod
++ def parse_type(m: Match[str]) -> str: ...
++ @staticmethod
++ def parse_title(m: Match[str]) -> str: ...
++ @staticmethod
++ def parse_content(m: Match[str]) -> str: ...
++
++class FencedDirective(BaseDirective):
++ parser = FencedParser
++ markers: Incomplete
++ directive_pattern: Incomplete
++ def __init__(self, plugins: List[DirectivePlugin], markers: str = "`~") -> None: ...
++ def parse_directive(
++ self, block: BlockParser, m: Match[str], state: BlockState
++ ) -> Optional[int]: ...
++ def parse_fenced_code(
++ self, block: BlockParser, m: Match[str], state: BlockState
++ ) -> Optional[int]: ...
++ def __call__(self, md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/directives/_rst.pyi
+@@ -0,0 +1,25 @@
++from typing import Match, Optional
++
++from ..block_parser import BlockParser
++from ..core import BlockState
++from ..markdown import Markdown
++from ._base import BaseDirective, DirectiveParser
++
++__all__ = ["RSTDirective"]
++
++class RSTParser(DirectiveParser):
++ name: str
++ @staticmethod
++ def parse_type(m: Match[str]) -> str: ...
++ @staticmethod
++ def parse_title(m: Match[str]) -> str: ...
++ @staticmethod
++ def parse_content(m: Match[str]) -> str: ...
++
++class RSTDirective(BaseDirective):
++ parser = RSTParser
++ directive_pattern: str
++ def parse_directive(
++ self, block: BlockParser, m: Match[str], state: BlockState
++ ) -> Optional[int]: ...
++ def __call__(self, markdown: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/directives/admonition.pyi
+@@ -0,0 +1,18 @@
++from typing import Any, Dict, Match
++
++from _typeshed import Incomplete
++
++from ..block_parser import BlockParser as BlockParser
++from ..core import BlockState as BlockState
++from ..markdown import Markdown as Markdown
++from ._base import BaseDirective as BaseDirective
++from ._base import DirectivePlugin as DirectivePlugin
++
++class Admonition(DirectivePlugin):
++ SUPPORTED_NAMES: Incomplete
++ def parse(self, block: BlockParser, m: Match[str], state: BlockState) -> Dict[str, Any]: ...
++ def __call__(self, directive: BaseDirective, md: Markdown) -> None: ...
++
++def render_admonition(self, text: str, name: str, **attrs: Any) -> str: ...
++def render_admonition_title(self, text: str) -> str: ...
++def render_admonition_content(self, text: str) -> str: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/directives/image.pyi
+@@ -0,0 +1,21 @@
++from typing import Any, Dict, List, Match, Optional
++
++from ..block_parser import BlockParser
++from ..core import BlockState
++from ..markdown import Markdown
++from ._base import BaseDirective, DirectivePlugin
++
++__all__ = ["Image", "Figure"]
++
++class Image(DirectivePlugin):
++ NAME: str
++ def parse(self, block: BlockParser, m: Match[str], state: BlockState) -> Dict[str, Any]: ...
++ def __call__(self, directive: BaseDirective, md: Markdown) -> None: ...
++
++class Figure(DirectivePlugin):
++ NAME: str
++ def parse_directive_content(
++ self, block: BlockParser, m: Match[str], state: BlockState
++ ) -> Optional[List[Dict[str, Any]]]: ...
++ def parse(self, block: BlockParser, m: Match[str], state: BlockState) -> Dict[str, Any]: ...
++ def __call__(self, directive: BaseDirective, md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/directives/include.pyi
+@@ -0,0 +1,16 @@
++from typing import Any, Dict, List, Match, Union
++
++from ..block_parser import BlockParser as BlockParser
++from ..core import BaseRenderer as BaseRenderer
++from ..core import BlockState as BlockState
++from ..markdown import Markdown as Markdown
++from ._base import BaseDirective as BaseDirective
++from ._base import DirectivePlugin as DirectivePlugin
++
++class Include(DirectivePlugin):
++ def parse(
++ self, block: BlockParser, m: Match[str], state: BlockState
++ ) -> Union[Dict[str, Any], List[Dict[str, Any]]]: ...
++ def __call__(self, directive: BaseDirective, md: Markdown) -> None: ...
++
++def render_html_include(renderer: BaseRenderer, text: str, **attrs: Any) -> str: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/directives/toc.pyi
+@@ -0,0 +1,25 @@
++from typing import Any, Dict, Match
++
++from _typeshed import Incomplete
++
++from ..block_parser import BlockParser as BlockParser
++from ..core import BaseRenderer as BaseRenderer
++from ..core import BlockState as BlockState
++from ..markdown import Markdown as Markdown
++from ..toc import normalize_toc_item as normalize_toc_item
++from ..toc import render_toc_ul as render_toc_ul
++from ._base import BaseDirective as BaseDirective
++from ._base import DirectivePlugin as DirectivePlugin
++
++class TableOfContents(DirectivePlugin):
++ min_level: Incomplete
++ max_level: Incomplete
++ def __init__(self, min_level: int = 1, max_level: int = 3) -> None: ...
++ def generate_heading_id(self, token: Dict[str, Any], index: int) -> str: ...
++ def parse(self, block: BlockParser, m: Match[str], state: BlockState) -> Dict[str, Any]: ...
++ def toc_hook(self, md: Markdown, state: BlockState) -> None: ...
++ def __call__(self, directive: BaseDirective, md: Markdown) -> None: ...
++
++def render_html_toc(
++ renderer: BaseRenderer, title: str, collapse: bool = False, **attrs: Any
++) -> str: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/helpers.pyi
+@@ -0,0 +1,30 @@
++from typing import Any, Dict, Tuple, Union
++
++from _typeshed import Incomplete
++
++from .util import escape_url as escape_url
++
++PREVENT_BACKSLASH: str
++PUNCTUATION: Incomplete
++LINK_LABEL: str
++LINK_BRACKET_START: Incomplete
++LINK_BRACKET_RE: Incomplete
++LINK_HREF_BLOCK_RE: Incomplete
++LINK_HREF_INLINE_RE: Incomplete
++LINK_TITLE_RE: Incomplete
++PAREN_END_RE: Incomplete
++HTML_TAGNAME: str
++HTML_ATTRIBUTES: str
++BLOCK_TAGS: Incomplete
++PRE_TAGS: Incomplete
++
++def unescape_char(text: str) -> str: ...
++def parse_link_text(src: str, pos: int) -> Union[Tuple[str, int], Tuple[None, None]]: ...
++def parse_link_label(src: str, start_pos: int) -> Union[Tuple[str, int], Tuple[None, None]]: ...
++def parse_link_href(
++ src: str, start_pos: int, block: bool = False
++) -> Union[Tuple[str, int], Tuple[None, None]]: ...
++def parse_link_title(
++ src: str, start_pos: int, max_pos: int
++) -> Union[Tuple[str, int], Tuple[None, None]]: ...
++def parse_link(src: str, pos: int) -> Union[Tuple[Dict[str, Any], int], Tuple[None, None]]: ...
--- python-schema-salad.orig/mypy-stubs/mistune/inline_parser.pyi
+++ python-schema-salad/mypy-stubs/mistune/inline_parser.pyi
-@@ -12,7 +12,7 @@
+@@ -1,76 +1,56 @@
+ from typing import (
++ Any,
+ ClassVar,
+- Generic,
+- Iterator,
++ Dict,
++ Iterable,
+ List,
+ Match,
++ MutableMapping,
+ Optional,
+ Pattern,
+- Tuple,
+- TypeVar,
+- Union,
)
- from mistune._types import State
+-from mistune._types import State
-from mistune.renderers import AstRenderer, DataT, HTMLRenderer
-+#from mistune.renderers import AstRenderer, DataT, HTMLRenderer
- from mistune.scanner import ScannerParser
- from mistune.util import ESCAPE_TEXT
- from typing_extensions import Literal
-@@ -24,53 +24,6 @@
- LINK_LABEL: str
-
- # Union[BaseRenderer[DataT], AstRenderer, HTMLRenderer]
+-from mistune.scanner import ScannerParser
+-from mistune.util import ESCAPE_TEXT
+-from typing_extensions import Literal
+-
+-HTML_TAGNAME: str
+-HTML_ATTRIBUTES: str
+-ESCAPE_CHAR: Pattern[str]
+-LINK_TEXT: str
+-LINK_LABEL: str
+-
+-# Union[BaseRenderer[DataT], AstRenderer, HTMLRenderer]
-RendererT = TypeVar("RendererT", bound=Union[AstRenderer, HTMLRenderer])
-+# RendererT = TypeVar("RendererT", bound=Union[AstRenderer, HTMLRenderer])
-
+-
-class InlineParser(ScannerParser, Generic[RendererT]):
- ESCAPE: ClassVar[str] = ESCAPE_TEXT
- AUTO_LINK: ClassVar[str]
@@ -170,7 +797,7 @@ Subject: [PATCH] update makedoc using mistune v3
- LINEBREAK: ClassVar[str]
- INLINE_HTML: ClassVar[str]
- RULE_NAMES: ClassVar[Tuple[str, ...]]
-
+-
- renderer: RendererT
-
- def __init__(self, renderer: RendererT, hard_wrap: bool = False) -> None: ...
@@ -206,22 +833,81 @@ Subject: [PATCH] update makedoc using mistune v3
- self, s: str, state: State, rules: Optional[List[str]]
- ) -> Union[DataT, List[DataT]]: ...
- def __call__(self, s: str, state: State) -> Union[DataT, List[DataT]]: ...
++from .core import InlineState as InlineState
++from .core import Parser as Parser
++from .helpers import HTML_ATTRIBUTES as HTML_ATTRIBUTES
++from .helpers import HTML_TAGNAME as HTML_TAGNAME
++from .helpers import PREVENT_BACKSLASH as PREVENT_BACKSLASH
++from .helpers import PUNCTUATION as PUNCTUATION
++from .helpers import parse_link as parse_link
++from .helpers import parse_link_label as parse_link_label
++from .helpers import parse_link_text as parse_link_text
++from .helpers import unescape_char as unescape_char
++from .util import escape as escape
++from .util import escape_url as escape_url
++from .util import unikey as unikey
++
++PAREN_END_RE: Pattern[str]
++AUTO_EMAIL: str
++INLINE_HTML: str
++EMPHASIS_END_RE: Dict[str, Pattern[str]]
++
++class InlineParser(Parser[InlineState]):
++ sc_flag: int
++ state_cls = InlineState
++ STD_LINEBREAK: str
++ HARD_LINEBREAK: str
++ SPECIFICATION: ClassVar[Dict[str, str]]
++ DEFAULT_RULES: ClassVar[Iterable[str]]
++ hard_wrap: bool
++ def __init__(self, hard_wrap: bool = False) -> None: ...
++ def parse_escape(self, m: Match[str], state: InlineState) -> int: ...
++ def parse_link(self, m: Match[str], state: InlineState) -> Optional[int]: ...
++ def parse_auto_link(self, m: Match[str], state: InlineState) -> int: ...
++ def parse_auto_email(self, m: Match[str], state: InlineState) -> int: ...
++ def parse_emphasis(self, m: Match[str], state: InlineState) -> int: ...
++ def parse_codespan(self, m: Match[str], state: InlineState) -> int: ...
++ def parse_linebreak(self, m: Match[str], state: InlineState) -> int: ...
++ def parse_softbreak(self, m: Match[str], state: InlineState) -> int: ...
++ def parse_inline_html(self, m: Match[str], state: InlineState) -> int: ...
++ def process_text(self, text: str, state: InlineState) -> None: ...
++ def parse(self, state: InlineState) -> List[Dict[str, Any]]: ...
++ def precedence_scan(
++ self, m: Match[str], state: InlineState, end_pos: int, rules: Optional[List[str]] = None
++ ) -> Optional[int]: ...
++ def render(self, state: InlineState) -> List[Dict[str, Any]]: ...
++ def __call__(self, s: str, env: MutableMapping[str, Any]) -> List[Dict[str, Any]]: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/list_parser.pyi
+@@ -0,0 +1,11 @@
++from typing import Match
++
++from .block_parser import BlockParser as BlockParser
++from .core import BlockState as BlockState
++from .util import expand_leading_tab as expand_leading_tab
++from .util import expand_tab as expand_tab
++from .util import strip_end as strip_end
++
++LIST_PATTERN: str
++
++def parse_list(block: BlockParser, m: Match[str], state: BlockState) -> int: ...
--- python-schema-salad.orig/mypy-stubs/mistune/markdown.pyi
+++ python-schema-salad/mypy-stubs/mistune/markdown.pyi
-@@ -1,29 +1,18 @@
- from typing import Any, Callable, Dict, Generic, Iterable, List, Match, Optional, Tuple
+@@ -1,35 +1,33 @@
+-from typing import Any, Callable, Dict, Generic, Iterable, List, Match, Optional, Tuple
++from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
- from mistune._types import State
+-from mistune._types import State
-from mistune.block_parser import BlockParser
-from mistune.inline_parser import InlineParser, RendererT
-from mistune.plugins import Plugin
-from mistune.renderers import BaseRenderer, DataT
-+from mistune.core import BaseRenderer
++from _typeshed import Incomplete
- Tokens = List[Dict[str, Any]]
+-Tokens = List[Dict[str, Any]]
-ParseHook = Callable[[Markdown[DataT, RendererT], DataT, State], Tuple[str, State]]
-RenderHook = Callable[[Markdown[DataT, RendererT], Tokens, State], Tokens]
-
+-
-class Markdown(Generic[DataT, RendererT]):
- renderer: BaseRenderer[DataT]
- inline: InlineParser[RendererT]
@@ -229,21 +915,199 @@ Subject: [PATCH] update makedoc using mistune v3
- before_parse_hooks: List[ParseHook[DataT, RendererT]]
- before_render_hooks: List[RenderHook[DataT, RendererT]]
- after_render_hooks: List[RenderHook[DataT, RendererT]]
-+class Markdown():
++from .block_parser import BlockParser as BlockParser
++from .core import BaseRenderer as BaseRenderer
++from .core import BlockState as BlockState
++from .inline_parser import InlineParser as InlineParser
++from .plugins import Plugin as Plugin
++class Markdown:
++ renderer: Incomplete
++ block: Incomplete
++ inline: Incomplete
++ before_parse_hooks: Incomplete
++ before_render_hooks: Incomplete
++ after_render_hooks: Incomplete
def __init__(
self,
- renderer: BaseRenderer[DataT],
-- block: Optional[BlockParser] = None,
++ renderer: Optional[BaseRenderer] = None,
+ block: Optional[BlockParser] = None,
- inline: Optional[InlineParser[RendererT]] = None,
-- plugins: Optional[Iterable[Plugin]] = None,
-+ renderer: BaseRenderer,
-+ block: Optional[Any] = None,
-+ inline: Optional[Any] = None,
-+ plugins: Optional[Iterable[Any]] = None,
++ inline: Optional[InlineParser] = None,
+ plugins: Optional[Iterable[Plugin]] = None,
) -> None: ...
- def before_parse(self, s: str, state: State) -> Tuple[str, State]: ...
- def before_render(self, tokens: Tokens, state: State) -> Tokens: ...
+- def before_parse(self, s: str, state: State) -> Tuple[str, State]: ...
+- def before_render(self, tokens: Tokens, state: State) -> Tokens: ...
+- def after_render(self, tokens: Tokens, state: State) -> Tokens: ...
+- def parse(self, s: str, state: Optional[State] = None) -> str: ...
+- def read(self, filepath: str, state: Optional[State] = None) -> str: ...
+- def __call__(self, s: str) -> str: ...
+-
+-def preprocess(s: str, state: State) -> Tuple[str, State]: ...
++ def use(self, plugin: Plugin) -> None: ...
++ def render_state(self, state: BlockState) -> Union[str, List[Dict[str, Any]]]: ...
++ def parse(
++ self, s: str, state: Optional[BlockState] = None
++ ) -> Tuple[Union[str, List[Dict[str, Any]]], BlockState]: ...
++ def read(
++ self, filepath: str, encoding: str = "utf-8", state: Optional[BlockState] = None
++ ) -> Tuple[Union[str, List[Dict[str, Any]]], BlockState]: ...
++ def __call__(self, s: str) -> Union[str, List[Dict[str, Any]]]: ...
+--- python-schema-salad.orig/mypy-stubs/mistune/plugins/__init__.pyi
++++ python-schema-salad/mypy-stubs/mistune/plugins/__init__.pyi
+@@ -1,21 +1,10 @@
+-from typing import Dict, Protocol
++from typing import Protocol, Union
+
+-from mistune.inline_parser import RendererT
+-from mistune.markdown import Markdown
+-from mistune.renderers import DataT
+-from typing_extensions import Literal
+-
+-PluginName = Literal[
+- "url",
+- "strikethrough",
+- "footnotes",
+- "table",
+- "task_lists",
+- "def_list",
+- "abbr",
+-]
++from ..markdown import Markdown
+
+ class Plugin(Protocol):
+- def __call__(self, markdown: Markdown[DataT, RendererT]) -> None: ...
++ def __call__(self, markdown: Markdown) -> None: ...
++
++PluginRef = Union[str, Plugin]
+
+-PLUGINS: Dict[PluginName, Plugin]
++def import_plugin(name: PluginRef) -> Plugin: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/plugins/abbr.pyi
+@@ -0,0 +1,5 @@
++from ..markdown import Markdown
++
++__all__ = ["abbr"]
++
++def abbr(md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/plugins/def_list.pyi
+@@ -0,0 +1,5 @@
++from ..markdown import Markdown
++
++__all__ = ["def_list"]
++
++def def_list(md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/plugins/footnotes.pyi
+@@ -0,0 +1,5 @@
++from ..markdown import Markdown
++
++__all__ = ["footnotes"]
++
++def footnotes(md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/plugins/formatting.pyi
+@@ -0,0 +1,9 @@
++from ..markdown import Markdown
++
++__all__ = ["strikethrough", "mark", "insert", "superscript", "subscript"]
++
++def strikethrough(md: Markdown) -> None: ...
++def mark(md: Markdown) -> None: ...
++def insert(md: Markdown) -> None: ...
++def superscript(md: Markdown) -> None: ...
++def subscript(md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/plugins/math.pyi
+@@ -0,0 +1,7 @@
++from ..markdown import Markdown
++
++__all__ = ["math", "math_in_quote", "math_in_list"]
++
++def math(md: Markdown) -> None: ...
++def math_in_quote(md: Markdown) -> None: ...
++def math_in_list(md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/plugins/ruby.pyi
+@@ -0,0 +1,18 @@
++from typing import Match
++
++from ..block_parser import BlockParser as BlockParser
++from ..core import BaseRenderer as BaseRenderer
++from ..core import BlockState as BlockState
++from ..core import InlineState as InlineState
++from ..core import Parser as Parser
++from ..helpers import parse_link as parse_link
++from ..helpers import parse_link_label as parse_link_label
++from ..inline_parser import InlineParser as InlineParser
++from ..markdown import Markdown as Markdown
++from ..util import unikey as unikey
++
++RUBY_PATTERN: str
++
++def parse_ruby(inline: InlineParser, m: Match[str], state: InlineState) -> int: ...
++def render_ruby(renderer: BaseRenderer, text: str, rt: str) -> str: ...
++def ruby(md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/plugins/speedup.pyi
+@@ -0,0 +1,5 @@
++from ..markdown import Markdown
++
++__all__ = ["speedup"]
++
++def speedup(md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/plugins/spoiler.pyi
+@@ -0,0 +1,5 @@
++from ..markdown import Markdown
++
++__all__ = ["spoiler"]
++
++def spoiler(md: Markdown) -> None: ...
+--- python-schema-salad.orig/mypy-stubs/mistune/plugins/table.pyi
++++ python-schema-salad/mypy-stubs/mistune/plugins/table.pyi
+@@ -1,17 +1,7 @@
+-import sys
+-from typing import Match
++from ..markdown import Markdown
+
+-from mistune._types import State
+-from mistune.block_parser import BlockParser, ParsedBlock
+-from mistune.inline_parser import RendererT
+-from mistune.markdown import Markdown
+-from mistune.renderers import DataT
+-from typing_extensions import Literal
++__all__ = ["table", "table_in_quote", "table_in_list"]
+
+-if sys.version_info >= (3, 7):
+- ParsedBlockTable = ParsedBlock[Literal["paragraph"]]
+-else:
+- ParsedBlockTable = ParsedBlock
+-
+-def parse_table(self: BlockParser, m: Match[str], state: State) -> ParsedBlockTable: ...
+-def plugin_table(md: Markdown[DataT, RendererT]) -> None: ...
++def table(md: Markdown) -> None: ...
++def table_in_quote(md: Markdown) -> None: ...
++def table_in_list(md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/plugins/task_lists.pyi
+@@ -0,0 +1,5 @@
++from ..markdown import Markdown
++
++__all__ = ["task_lists"]
++
++def task_lists(md: Markdown) -> None: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/plugins/url.pyi
+@@ -0,0 +1,5 @@
++from ..markdown import Markdown
++
++__all__ = ["url"]
++
++def url(md: Markdown) -> None: ...
--- python-schema-salad.orig/mypy-stubs/mistune/renderers.pyi
+++ /dev/null
@@ -1,109 +0,0 @@
@@ -356,6 +1220,169 @@ Subject: [PATCH] update makedoc using mistune v3
- ) -> HTMLType: ...
- def list_item(self, text: str, level: int) -> HTMLType: ...
- def finalize(self, data: DataT) -> HTMLType: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/renderers/_list.pyi
+@@ -0,0 +1,7 @@
++from typing import Any, Dict
++
++from ..core import BaseRenderer as BaseRenderer
++from ..core import BlockState as BlockState
++from ..util import strip_end as strip_end
++
++def render_list(renderer: BaseRenderer, token: Dict[str, Any], state: BlockState) -> str: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/renderers/html.pyi
+@@ -0,0 +1,39 @@
++from typing import Any, ClassVar, Dict, Optional, Tuple
++
++from typing_extensions import Literal
++
++from ..core import BaseRenderer as BaseRenderer
++from ..core import BlockState as BlockState
++from ..util import safe_entity as safe_entity
++from ..util import striptags as striptags
++
++class HTMLRenderer(BaseRenderer):
++ NAME: ClassVar[Literal["html"]]
++ HARMFUL_PROTOCOLS: ClassVar[Tuple[str, ...]]
++ GOOD_DATA_PROTOCOLS: ClassVar[Tuple[str, ...]]
++ _escape: bool
++ def __init__(
++ self, escape: bool = True, allow_harmful_protocols: Optional[bool] = None
++ ) -> None: ...
++ def render_token(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def safe_url(self, url: str) -> str: ...
++ def text(self, text: str) -> str: ...
++ def emphasis(self, text: str) -> str: ...
++ def strong(self, text: str) -> str: ...
++ def link(self, text: str, url: str, title: Optional[str] = None) -> str: ...
++ def image(self, text: str, url: str, title: Optional[str] = None) -> str: ...
++ def codespan(self, text: str) -> str: ...
++ def linebreak(self) -> str: ...
++ def softbreak(self) -> str: ...
++ def inline_html(self, html: str) -> str: ...
++ def paragraph(self, text: str) -> str: ...
++ def heading(self, text: str, level: int, **attrs: Any) -> str: ...
++ def blank_line(self) -> str: ...
++ def thematic_break(self) -> str: ...
++ def block_text(self, text: str) -> str: ...
++ def block_code(self, code: str, info: Optional[str] = None) -> str: ...
++ def block_quote(self, text: str) -> str: ...
++ def block_html(self, html: str) -> str: ...
++ def block_error(self, text: str) -> str: ...
++ def list(self, text: str, ordered: bool, **attrs: Any) -> str: ...
++ def list_item(self, text: str) -> str: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/renderers/markdown.pyi
+@@ -0,0 +1,35 @@
++from typing import Any, Dict, Iterable
++
++from _typeshed import Incomplete
++
++from ..core import BaseRenderer as BaseRenderer
++from ..core import BlockState as BlockState
++from ..util import strip_end as strip_end
++from ._list import render_list as render_list
++
++fenced_re: Incomplete
++
++class MarkdownRenderer(BaseRenderer):
++ NAME: str
++ def __call__(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> str: ...
++ def render_referrences(self, state: BlockState) -> Iterable[str]: ...
++ def render_children(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def text(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def emphasis(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def strong(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def link(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def image(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def codespan(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def linebreak(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def softbreak(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def blank_line(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def inline_html(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def paragraph(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def heading(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def thematic_break(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def block_text(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def block_code(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def block_quote(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def block_html(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def block_error(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def list(self, token: Dict[str, Any], state: BlockState) -> str: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/renderers/rst.pyi
+@@ -0,0 +1,35 @@
++from typing import Any, Dict, Iterable
++
++from _typeshed import Incomplete
++
++from ..core import BaseRenderer as BaseRenderer
++from ..core import BlockState as BlockState
++from ..util import strip_end as strip_end
++from ._list import render_list as render_list
++
++class RSTRenderer(BaseRenderer):
++ NAME: str
++ HEADING_MARKERS: Incomplete
++ INLINE_IMAGE_PREFIX: str
++ def iter_tokens(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> Iterable[str]: ...
++ def __call__(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> str: ...
++ def render_referrences(self, state: BlockState) -> Iterable[str]: ...
++ def render_children(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def text(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def emphasis(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def strong(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def link(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def image(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def codespan(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def linebreak(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def softbreak(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def inline_html(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def paragraph(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def heading(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def thematic_break(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def block_text(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def block_code(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def block_quote(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def block_html(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def block_error(self, token: Dict[str, Any], state: BlockState) -> str: ...
++ def list(self, token: Dict[str, Any], state: BlockState) -> str: ...
+--- /dev/null
++++ python-schema-salad/mypy-stubs/mistune/toc.pyi
+@@ -0,0 +1,14 @@
++from typing import Any, Callable, Dict, Iterable, Optional, Tuple
++
++from .core import BlockState as BlockState
++from .markdown import Markdown as Markdown
++from .util import striptags as striptags
++
++def add_toc_hook(
++ md: Markdown,
++ min_level: int = 1,
++ max_level: int = 3,
++ heading_id: Optional[Callable[[Dict[str, Any], int], str]] = None,
++) -> None: ...
++def normalize_toc_item(md: Markdown, token: Dict[str, Any]) -> Tuple[int, str, str]: ...
++def render_toc_ul(toc: Iterable[Tuple[int, str, str]]) -> str: ...
+--- python-schema-salad.orig/mypy-stubs/mistune/util.pyi
++++ python-schema-salad/mypy-stubs/mistune/util.pyi
+@@ -1,7 +1,9 @@
+-PUNCTUATION: str
+-ESCAPE_TEXT: str
+-
+-def escape(text: str, quote: bool = True) -> str: ...
+-def escape_html(s: str) -> str: ...
+-def escape_url(s: str) -> str: ...
++def expand_leading_tab(text: str, width: int = 4) -> str: ...
++def expand_tab(text: str, space: str = " ") -> str: ...
++def escape(s: str, quote: bool = True) -> str: ...
++def escape_url(link: str) -> str: ...
++def safe_entity(s: str) -> str: ...
+ def unikey(s: str) -> str: ...
++def unescape(s: str) -> str: ...
++def striptags(s: str) -> str: ...
++def strip_end(src: str) -> str: ...
--- python-schema-salad.orig/requirements.txt
+++ python-schema-salad/requirements.txt
@@ -1,7 +1,7 @@
@@ -367,9 +1394,20 @@ Subject: [PATCH] update makedoc using mistune v3
CacheControl[filecache]>= 0.11.7, < 0.14
black>=19.10b0,<23.13
mypy_extensions
+--- python-schema-salad.orig/schema_salad/cpp_codegen.py
++++ python-schema-salad/schema_salad/cpp_codegen.py
+@@ -940,7 +940,7 @@
+ break
+
+ if not found:
+- self.classDefinitions[key].fields.append(field)
++ self.classDefinitions[key].fields.append(field) # noqa: B038
+
+ # write definitions
+ for key in self.enumDefinitions:
--- python-schema-salad.orig/schema_salad/makedoc.py
+++ python-schema-salad/schema_salad/makedoc.py
-@@ -8,10 +8,10 @@
+@@ -8,37 +8,47 @@
from io import StringIO, TextIOWrapper
from typing import (
IO,
@@ -381,13 +1419,16 @@ Subject: [PATCH] update makedoc using mistune v3
MutableMapping,
MutableSequence,
Optional,
-@@ -22,23 +22,32 @@
+ Set,
+ Tuple,
+ Union,
++ cast,
+ )
from urllib.parse import urldefrag
from mistune import create_markdown
-from mistune.renderers import HTMLRenderer
-from mistune.util import escape_html
-+from mistune.core import BlockState
+from mistune.markdown import Markdown
+from mistune.renderers.html import HTMLRenderer
@@ -415,13 +1456,14 @@ Subject: [PATCH] update makedoc using mistune v3
+def escape_html(s: str) -> str:
-+ return html.escape(html.unescape(s)).replace(''', "'")
++ """Escape HTML but otherwise preserve single quotes."""
++ return html.escape(html.unescape(s)).replace("'", "'")
+
+
def vocab_type_name(url: str) -> str:
"""Remove the avro namespace, if any."""
return avro_type_name(url).split(".")[-1]
-@@ -70,7 +79,7 @@
+@@ -70,7 +80,7 @@
class MyRenderer(HTMLRenderer):
"""Custom renderer with different representations of selected HTML tags."""
@@ -430,38 +1472,147 @@ Subject: [PATCH] update makedoc using mistune v3
"""Override HTML heading creation with text IDs."""
return """<h{} id="{}" class="section">{} <a href="#{}">§</a></h{}>""".format(
level, to_id(text), text, to_id(text), level
-@@ -104,9 +113,10 @@
+@@ -104,139 +114,6 @@
return text + ">" + html.escape(code, quote=self._escape) + "</code></pre>\n"
-+# FIXME: this can be removed with mistune v3!
- def markdown_list_hook(
+-def markdown_list_hook(
- markdown: "Markdown[str, Any]", text: str, state: "State"
-) -> Tuple[str, "State"]:
-+ markdown: Markdown, state: BlockState, text: Optional[str] = None,
-+) -> Tuple[str, BlockState]:
- """Patches problematic Markdown lists for later HTML generation.
-
- When a Markdown list with paragraphs not indented with the list
-@@ -154,6 +164,8 @@
- r"(?P<remain>.*)",
- re.MULTILINE,
- )
-+ if text is None:
-+ text = state.src
- matches = list(re.finditer(pattern, text))
- if not matches:
- return text, state
-@@ -179,7 +191,7 @@
- if line.strip()
- ]
- )
+- """Patches problematic Markdown lists for later HTML generation.
+-
+- When a Markdown list with paragraphs not indented with the list
+- markers (no spaces before following lines), ``mistune`` v2 does
+- not handle them correctly. This is however permitted as per
+- https://daringfireball.net/projects/markdown/syntax#list
+-
+- For example:
+-
+- ```markdown
+- * some list
+- * item with
+- paragraph
+- * other item
+- ```
+-
+- Similarly, lists that are completely indented or that contains nested lists
+- produce incorrect HTML ``<p>``/``<li>`` tag combinations.
+-
+- Because list parsing is deeply nested within ``mistune.block_parser.BlockParser``
+- and that there is no easy way to override utility functions it employs to adjust
+- patterns of list items without reimplementing it or a lot of monkey patching,
+- instead catch the problem cases before rendering and adjust them with a hook.
+-
+- See https://github.com/lepture/mistune/issues/296
+- and https://github.com/common-workflow-language/schema_salad/pull/619
+- """
+- pattern = re.compile(
+- r"^"
+- r"(?P<before>\n*)" # detect newline to start capture on bullet line
+- r"(?P<indent>\s*)"
+- r"(?P<bullet>[0-9]+[.)]?|[*-])"
+- r"(?P<spacing>\s+)"
+- r"(?P<first_line>.*)"
+- # if more than one empty line is found, end search (paragraph after list)
+- r"(?!\n\s*\n\s*)"
+- # otherwise, find all lines part of the same bullet item
+- # if this bullet item is indented (nested list), match indents to collect
+- # use negative lookahead to avoid over capturing following bullets
+- r"(?P<other_lines>(?:\n\s*(?![0-9]+[.)]+|[*-])(?P=indent).*"
+- r"(?!\n\s*\n\s*)" # avoid match past list on last indented line
+- r")+)*" # end 'other_lines'
+- # because of negative lookahead logic, there is sometimes a remaining
+- # trailing character to capture on the last list item line
+- r"(?P<remain>.*)",
+- re.MULTILINE,
+- )
+- matches = list(re.finditer(pattern, text))
+- if not matches:
+- return text, state
+- result = ""
+- begin = 0
+- for match in matches:
+- start, end = match.start(), match.end()
+- start += len(match.group("before"))
+- result += text[begin:start] # add text in between matched lists
+-
+- # process and indented list (de-indent, apply fixes, and re-indent)
+- indent_prefix = match.group("indent")
+- if indent_prefix:
+- intend_list = text[start:end]
+- intend_list = "\n".join(
+- [
+- line.strip()
+- for line in intend_list.split("\n")
+- # mistune is having trouble understanding list items
+- # if they are separated by an additional line in between
+- # ignore empty lines to group items together,
+- # avoiding split into distinct list after injecting <p> tags
+- if line.strip()
+- ]
+- )
- intend_list, _ = markdown_list_hook(markdown, intend_list, state)
-+ intend_list, _ = markdown_list_hook(markdown, state, intend_list)
- # remove final newline from other if/else branch
- intend_list = intend_list.rstrip()
- intend_list = "\n".join([indent_prefix + line for line in intend_list.split("\n")])
-@@ -583,7 +595,7 @@
+- # remove final newline from other if/else branch
+- intend_list = intend_list.rstrip()
+- intend_list = "\n".join([indent_prefix + line for line in intend_list.split("\n")])
+- result += intend_list + "\n"
+- # process a plain list
+- # pad extra spaces to multi-lines items contents after bullet
+- else:
+- item = match.group("indent") + match.group("bullet") + match.group("spacing")
+- result += item + match.group("first_line")
+- indent = (
+- "\n"
+- + match.group("indent").split("\n")[-1]
+- + (" " * len(match.group("bullet")))
+- + match.group("spacing")
+- )
+- other = match.group("other_lines")
+- if other:
+- other = indent.join(
+- [
+- line.strip()
+- for line in other.split("\n")
+- # mistune is having trouble understanding list items
+- # if they are separated by an additional line in between
+- # ignore empty lines to group items together,
+- # avoiding split into distinct list after injecting <p> tags
+- if line.strip()
+- ]
+- )
+- # Add a single space to ensure words remain separated.
+- # If we use newline/indent like in other lines above, mistune
+- # splits the items into 2 lists. Although technically the Markdown
+- # will have an extra space, spacing will be patched when generating
+- # the HTML whether newline or space was used.
+- if (
+- # only apply the extra space if items are actually
+- # 2 words to avoid incorrect split of compound words
+- # (e.g.: "key-value", not "key- value").
+- re.match(r".*[^-]$", result[-2:], re.I)
+- and re.match(r"^[^-].*", other[:2], re.I)
+- ):
+- result += " "
+- result += other
+- result += match.group("remain") + "\n"
+-
+- begin = end + 1
+- result += text[begin:]
+- # Because lists regexes are designed to detect line-by-line bullets/paragraphs,
+- # we cannot directly (or easily / with certainty) detect "list-like" encase in
+- # fenced code definitions that could be much above/below the "list-like" items.
+- # Instead, simply revert them after the fact with document-level matches of fenced codes.
+- _logger.debug("Original Markdown:\n\n%s\n\n", text)
+- _logger.debug("Modified Markdown:\n\n%s\n\n", result)
+- result = patch_fenced_code(text, result)
+- _logger.debug("Patched Markdown:\n\n%s\n\n", result)
+- return result, state
+-
+-
+ def patch_fenced_code(original_markdown_text: str, modified_markdown_text: str) -> str:
+ """Reverts fenced code fragments found in the modified contents back to their original definition."""
+ # Pattern inspired from 'mistune.block_parser.BlockParser.FENCED_CODE'.
+@@ -583,7 +460,7 @@
f["doc"] = number_headings(self.toc, f["doc"])
doc = doc + "\n\n" + f["doc"]
@@ -470,7 +1621,7 @@ Subject: [PATCH] update makedoc using mistune v3
"strikethrough",
"footnotes",
"table",
-@@ -592,12 +604,12 @@
+@@ -592,13 +469,12 @@
# if escape active, wraps literal HTML into '<p> {HTML} </p>'
# we must pass it to both since 'MyRenderer' is predefined
escape = False
@@ -481,10 +1632,37 @@ Subject: [PATCH] update makedoc using mistune v3
escape=escape,
)
- markdown2html.before_parse_hooks.append(markdown_list_hook)
-+ ##markdown2html.before_parse_hooks.append(markdown_list_hook) # FIXME: this can be removed with mistune v3!
- doc = markdown2html(doc)
+- doc = markdown2html(doc)
++ doc = cast(str, markdown2html(doc))
if f["type"] == "record":
+ doc += "<h3>Fields</h3>"
+--- python-schema-salad.orig/schema_salad/tests/test_makedoc.py
++++ python-schema-salad/schema_salad/tests/test_makedoc.py
+@@ -193,14 +193,14 @@
+ # Some newlines in markdown are replaced by spaces purposely
+ # to avoid invalid Markdown to HTML conversion as preserve words separated.
+ assert (
+- "<li><p>At least one record definition object which defines valid fields that " # purposely no \n
++ "<li><p>At least one record definition object which defines valid fields that\n"
+ "make up a record type. Record field definitions include the valid types\n"
+ "that may be assigned to each field and annotations to indicate fields\n"
+ 'that represent identifiers and links, described below in "Semantic\n'
+ 'Annotations".</p>\n'
+ "</li>\n"
+ "<li><p>Any number of enumerated type objects which define a set of finite "
+- "set of symbols that are " # purposely no \n
++ "set of symbols that are\n"
+ "valid value of the type.</p>\n"
+ "</li>\n"
+ "<li><p>Any number of documentation objects which allow in-line "
+@@ -239,5 +239,5 @@
+ with open(result, "w") as h:
+ h.write(metaschema_doc)
+ assert (
+- hasher.hexdigest() == "92730b4fd87186421b7e5f656f15280461beeb8d7bb853e405ae85238bb12580"
++ hasher.hexdigest() == "3218d5a66d13025a874c0c05e0ad9af26d6131a4e27c019589b4aa18aee3c73d"
+ ), result
--- python-schema-salad.orig/setup.py
+++ python-schema-salad/setup.py
@@ -87,7 +87,7 @@
@@ -496,78 +1674,68 @@ Subject: [PATCH] update makedoc using mistune v3
"CacheControl[filecache] >= 0.11.7, < 0.14",
"mypy_extensions",
"importlib_resources>=1.4;python_version<'3.9'",
---- /dev/null
-+++ python-schema-salad/mypy-stubs/mistune/core.pyi
-@@ -0,0 +1,26 @@
-+from typing import Any, Callable, ClassVar, Generic, List, Optional, Set, TypeVar, Union, Mapping
-+from collections.abc import Generator
-+from typing import Any, Dict
-+
-+class BlockState:
-+ src: str
-+ tokens: List[Any]
-+ cursor: int
-+ cursor_max: int
-+ list_tight: bool
-+ parent: Any
-+ env: Mapping[str, Any]
-+ def __init__(self, parent: Optional[Any] = None) -> None: ...
-+ def child_state(self, src: str) -> BlockState: ...
-+ def process(self, src: str) -> None: ...
-+ def get_text(self, end_pos: int) -> str: ...
-+ def last_token(self) -> Any: ...
-+ def prepend_token(self, token: Dict[str, Any]) -> None: ...
-+ def append_token(self, token: Dict[str, Any]) -> None: ...
-+ def add_paragraph(self, text: str) -> None: ...
-+ def append_paragraph(self) -> None: ...
-+ def depth(self) -> int: ...
-+
-+class BaseRenderer:
-+ NAME: ClassVar[str] = "base"
-+ def __init__(self) -> None: ...
---- /dev/null
-+++ python-schema-salad/mypy-stubs/mistune/renderers/html.pyi
-@@ -0,0 +1,29 @@
-+from ..core import BaseRenderer as BaseRenderer
-+from typing import Any, Callable, ClassVar, Generic, List, Optional, Set, TypeVar, Union, Literal
-+
-+class HTMLRenderer(BaseRenderer):
-+ NAME: ClassVar[Literal["html"]] = "html"
-+ HARMFUL_PROTOCOLS: ClassVar[Set[str]]
-+ GOOD_DATA_PROTOCOLS: ClassVar[Set[str]]
-+ _escape: bool
-+ def __init__(self, escape: bool = ..., allow_harmful_protocols: Optional[bool] = ...) -> None: ...
-+ def text(self, text: str) -> str: ...
-+ def emphasis(self, text: str) -> str: ...
-+ def strong(self, text: str) -> str: ...
-+ def link(self, text: str, url: str, title: Optional[str] = ...) -> str: ...
-+ def image(self, text: str, url: str, title: Optional[str] = ...) -> str: ...
-+ def codespan(self, text: str) -> str: ...
-+ def linebreak(self) -> str: ...
-+ def softbreak(self) -> str: ...
-+ def inline_html(self, html: str) -> str: ...
-+ def paragraph(self, text: str) -> str: ...
-+ def heading(self, text: str, level: int, **attrs: Any) -> str: ...
-+ def blank_line(self) -> str: ...
-+ def thematic_break(self) -> str: ...
-+ def block_text(self, text: str) -> str: ...
-+ def block_code(self, code: str, info: Optional[str] = ...) -> str: ...
-+ def block_quote(self, text: str) -> str: ...
-+ def block_html(self, html: str) -> str: ...
-+ def block_error(self, text: str) -> str: ...
-+ def list(self, text: str, ordered: bool, **attrs: Any) -> str: ...
-+ def list_item(self, text: str) -> str: ...
---- /dev/null
-+++ python-schema-salad/mypy-stubs/mistune/renderers/__init__.pyi
-@@ -0,0 +1,2 @@
-+
-+
---- python-schema-salad.orig/schema_salad/tests/test_makedoc.py
-+++ python-schema-salad/schema_salad/tests/test_makedoc.py
-@@ -239,5 +239,5 @@
- with open(result, "w") as h:
- h.write(metaschema_doc)
- assert (
-- hasher.hexdigest() == "92730b4fd87186421b7e5f656f15280461beeb8d7bb853e405ae85238bb12580"
-+ hasher.hexdigest() == "3218d5a66d13025a874c0c05e0ad9af26d6131a4e27c019589b4aa18aee3c73d"
- ), result
+--- python-schema-salad.orig/mypy-stubs/mistune/scanner.pyi
++++ /dev/null
+@@ -1,62 +0,0 @@
+-from typing import (
+- Any,
+- Callable,
+- ClassVar,
+- Dict,
+- Iterable,
+- Iterator,
+- List,
+- Match,
+- Pattern,
+- Tuple,
+- Type,
+- Union,
+-)
+-
+-from mistune._types import State
+-from typing_extensions import TypeAlias
+-
+-MethodFunc: TypeAlias = Callable[["ScannerParser", Match[str], State], Any]
+-RuleMethod = Tuple[Pattern[str], MethodFunc]
+-Lexicon = List[Tuple[Pattern[str], Tuple[str, RuleMethod]]]
+-TextParser = Callable[[str, State], str]
+-
+-class SREScanner: # real type unknown
+- def __init__(self, lexicon: Lexicon) -> None: ...
+- def scanner(self, string: str) -> Pattern[str]: ...
+-
+-class Scanner(object):
+- scanner: ClassVar[SREScanner]
+- lexicon: Lexicon
+-
+- def iter(
+- self,
+- string: str,
+- state: State,
+- parse_text: TextParser,
+- ) -> Iterator[str]: ...
+-
+-class Matcher:
+- PARAGRAPH_END: ClassVar[Pattern[str]]
+- lexicon: Lexicon
+-
+- def __init__(self, lexicon: Lexicon) -> None: ...
+- def search_pos(self, string: str, pos: int) -> int: ...
+- def iter(self, string: str, state: State, parse_text: TextParser) -> Iterator[str]: ...
+-
+-class ScannerParser:
+- RULE_NAMES: ClassVar[Tuple[str, ...]]
+- scanner_cls: ClassVar[Union[Type[SREScanner], Type[Matcher]]]
+- rules: List[str]
+- rule_methods: Dict[str, RuleMethod]
+- _cached_sc: Dict[str, Scanner]
+-
+- def __init__(self) -> None: ...
+- def register_rule(self, name: str, patter: Pattern[str], method: RuleMethod) -> None: ...
+- def get_rule_pattern(self, name: str) -> Pattern[str]: ...
+- def get_rule_method(self, name: str) -> RuleMethod: ...
+- def parse_text(
+- self, text: str, state: State
+- ) -> Any: ... # abstract method, return specialized by implementation
+- def _scan(self, s: str, state: State, rules: Iterable[str]) -> Iterator[str]: ...
+- def _create_scanner(self, rules: Iterable[str]) -> Scanner: ...
=====================================
debian/rules
=====================================
@@ -41,7 +41,7 @@ ifeq (,$(filter nocheck,$(DEB_BUILD_OPTIONS)))
PYBUILD_SYSTEM=custom \
PYBUILD_TEST_ARGS="cd {dir}; export PATH={destdir}/usr/bin:$$PATH ; \
cd {build_dir}; export PYTHONPATH=$$(pwd); {interpreter} -m pytest \
- -rs -n auto -k 'not (test_secondaryFiles or test_outputBinding or test_yaml_tab_error or test_bad_schemas or test_multiline_list_entries_without_indention)' \
+ -rs -n auto -k 'not (test_secondaryFiles or test_outputBinding or test_yaml_tab_error or test_bad_schemas)' \
--pyargs schema_salad" dh_auto_test
endif
=====================================
debian/tests/run-tests
=====================================
@@ -5,4 +5,4 @@ if [ "$AUTOPKGTEST_TMP" = "" ] ; then
AUTOPKGTEST_TMP=$(mktemp -d /tmp/${pkg}-test.XXXXXX)
fi
cd "$AUTOPKGTEST_TMP"
-py.test-3 -rs --numprocesses=auto --pyargs schema_salad -n 'not test_multiline_list_entries_without_indention'
+py.test-3 -rs --numprocesses=auto --pyargs schema_salad
View it on GitLab: https://salsa.debian.org/python-team/packages/python-schema-salad/-/compare/c9f26db59b0dfab2a536a61dec0f9d0d17300401...d29a7a49e10ab0d3be7d76e1d3f7e86a6266ac9f
--
View it on GitLab: https://salsa.debian.org/python-team/packages/python-schema-salad/-/compare/c9f26db59b0dfab2a536a61dec0f9d0d17300401...d29a7a49e10ab0d3be7d76e1d3f7e86a6266ac9f
You're receiving this email because of your account on salsa.debian.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://alioth-lists.debian.net/pipermail/debian-med-commit/attachments/20240118/cec6573f/attachment-0001.htm>
More information about the debian-med-commit
mailing list