diff --git a/stubs/docutils/docutils/nodes.pyi b/stubs/docutils/docutils/nodes.pyi index f9a15b5a9..825f0c373 100644 --- a/stubs/docutils/docutils/nodes.pyi +++ b/stubs/docutils/docutils/nodes.pyi @@ -88,6 +88,7 @@ class Node: # Left out # - def ensure_str (deprecated) # - def unescape (canonical import from docutils.utils) +def unescape(text: str, restore_backslashes: bool = False, respect_whitespace: bool = False) -> str: ... class Text(Node, str): tagname: ClassVar[str] diff --git a/stubs/docutils/docutils/utils/__init__.pyi b/stubs/docutils/docutils/utils/__init__.pyi index 898aade85..9299145af 100644 --- a/stubs/docutils/docutils/utils/__init__.pyi +++ b/stubs/docutils/docutils/utils/__init__.pyi @@ -2,25 +2,29 @@ import optparse from _typeshed import StrPath, SupportsWrite, Unused from collections.abc import Callable, Iterable, Mapping from re import Pattern -from typing import Any, Literal, TypeVar +from typing import Any, Final, Literal, TypeVar from typing_extensions import TypeAlias from docutils import ApplicationError, DataError, nodes from docutils.frontend import Values from docutils.io import ErrorOutput, FileOutput -from docutils.nodes import document +from docutils.nodes import document, unescape as unescape +_T = TypeVar("_T") _Observer: TypeAlias = Callable[[nodes.system_message], object] +_SystemMessageLevel: TypeAlias = Literal[0, 1, 2, 3, 4] + +__docformat__: Final = "reStructuredText" class DependencyList: list: list[str] file: FileOutput | None def __init__(self, output_file: str | None = None, dependencies: Iterable[str] = ()) -> None: ... def set_output(self, output_file: str | None) -> None: ... - def add(self, *filenames: str) -> None: ... + def add(self, *paths: str) -> None: ... def close(self) -> None: ... -_SystemMessageLevel: TypeAlias = Literal[0, 1, 2, 3, 4] +class SystemMessagePropagation(ApplicationError): ... class Reporter: levels: list[str] @@ -127,13 +131,10 @@ def column_indices(text: str) -> list[int]: ... east_asian_widths: dict[str, int] def column_width(text: str) -> int: ... - -_T = TypeVar("_T") - def uniq(L: list[_T]) -> list[_T]: ... def normalize_language_tag(tag: str) -> list[str]: ... +def xml_declaration(encoding: str | None = None) -> str: ... release_level_abbreviations: dict[str, str] def version_identifier(version_info: tuple[int, int, int, str, int, bool] | None = None) -> str: ... -def unescape(text: str, restore_backslashes: bool = False, respect_whitespace: bool = False) -> str: ... diff --git a/stubs/docutils/docutils/utils/code_analyzer.pyi b/stubs/docutils/docutils/utils/code_analyzer.pyi new file mode 100644 index 000000000..73313a959 --- /dev/null +++ b/stubs/docutils/docutils/utils/code_analyzer.pyi @@ -0,0 +1,28 @@ +from collections.abc import Generator, Iterable +from typing import Literal +from typing_extensions import TypeAlias + +from docutils import ApplicationError + +_TokenNames: TypeAlias = Literal["long", "short", "none"] + +with_pygments: bool +unstyled_tokens: list[str] + +class LexerError(ApplicationError): ... + +class Lexer: + code: str + language: str + tokennames: _TokenNames + lexer: Lexer | None + def __init__(self, code: str, language: str, tokennames: _TokenNames = "short") -> None: ... + def merge(self, tokens: Iterable[tuple[_TokenNames, str]]) -> Generator[tuple[_TokenNames, str]]: ... + def __iter__(self) -> Generator[tuple[list[str], str]]: ... + +class NumberLines: + tokens: Iterable[tuple[list[str], str]] + startline: int + fmt_str: str + def __init__(self, tokens: Iterable[tuple[list[str], str]], startline: int, endline: int) -> None: ... + def __iter__(self) -> Generator[tuple[list[str], str]]: ... diff --git a/stubs/docutils/docutils/utils/error_reporting.pyi b/stubs/docutils/docutils/utils/error_reporting.pyi new file mode 100644 index 000000000..eed08a3c7 --- /dev/null +++ b/stubs/docutils/docutils/utils/error_reporting.pyi @@ -0,0 +1,41 @@ +from io import TextIOWrapper +from typing import TextIO +from typing_extensions import TypeAlias, deprecated + +unicode = str + +_DataType: TypeAlias = str | Exception + +@deprecated("`docutils.utils.error_reporting` module is deprecated and will be removed in Docutils 0.21 or later.") +class SafeString: + data: object + encoding: str + encoding_errors: str + decoding_errors: str + def __init__( + self, + data: object, + encoding: str | None = None, + encoding_errors: str = "backslashreplace", + decoding_errors: str = "replace", + ) -> None: ... + def __unicode__(self) -> str: ... + +@deprecated("`docutils.utils.error_reporting` module is deprecated and will be removed in Docutils 0.21 or later.") +class ErrorString(SafeString): ... + +@deprecated("`docutils.utils.error_reporting` module is deprecated and will be removed in Docutils 0.21 or later.") +class ErrorOutput: + stream: TextIO | TextIOWrapper + encoding: str + encoding_errors: str + decoding_errors: str + def __init__( + self, + stream=None, + encoding: str | None = None, + encoding_errors: str = "backslashreplace", + decoding_errors: str = "replace", + ) -> None: ... + def write(self, data: _DataType) -> None: ... + def close(self) -> None: ... diff --git a/stubs/docutils/docutils/utils/math/__init__.pyi b/stubs/docutils/docutils/utils/math/__init__.pyi new file mode 100644 index 000000000..3504ef143 --- /dev/null +++ b/stubs/docutils/docutils/utils/math/__init__.pyi @@ -0,0 +1,11 @@ +from typing import Literal + +from docutils.nodes import Node + +class MathError(ValueError): + details: list[Node] + def __init__(self, msg: object, details: list[Node] = []) -> None: ... + +def toplevel_code(code: str) -> str: ... +def pick_math_environment(code: str, numbered: bool = False) -> Literal["align*", "equation*", "align", "equation"]: ... +def wrap_math_code(code: str, as_block: bool | None) -> str: ... diff --git a/stubs/docutils/docutils/utils/math/latex2mathml.pyi b/stubs/docutils/docutils/utils/math/latex2mathml.pyi new file mode 100644 index 000000000..8adda7596 --- /dev/null +++ b/stubs/docutils/docutils/utils/math/latex2mathml.pyi @@ -0,0 +1,44 @@ +from collections.abc import Iterable + +from docutils.utils.math.mathml_elements import MathElement, mover, msub, msubsup, msup, mtd, munder, munderover + +letters: dict[str, str] +ordinary: dict[str, str] +greek_capitals: dict[str, str] +functions: dict[str, str | None] +modulo_functions: dict[str, tuple[bool, bool, bool, str]] +math_alphabets: dict[str, str] +stretchables: dict[str, str] +operators: dict[str, str] +thick_operators: dict[str, str] +small_operators: dict[str, str] +movablelimits: tuple[str, ...] +spaces: dict[str, str] +accents: dict[str, str] +over: dict[str, tuple[str, float]] +under: dict[str, tuple[str, float]] +anomalous_chars: dict[str, str] +mathbb: dict[str, str] +matrices: dict[str, tuple[str, str]] +layout_styles: dict[str, dict[str, bool | int]] +fractions: dict[str, dict[str, bool | int | str] | dict[str, bool | int] | dict[str, int]] +delimiter_sizes: list[str] +bigdelimiters: dict[str, int] + +def tex_cmdname(string: str) -> tuple[str, str]: ... +def tex_number(string: str) -> tuple[str, str]: ... +def tex_token(string: str) -> tuple[str, str]: ... +def tex_group(string: str) -> tuple[str, str]: ... +def tex_token_or_group(string: str) -> tuple[str, str]: ... +def tex_optarg(string: str) -> tuple[str, str]: ... +def parse_latex_math(root: MathElement, source: str) -> MathElement: ... +def handle_cmd(name: str, node: MathElement, string: str) -> tuple[MathElement, str]: ... +def handle_math_alphabet(name: str, node: MathElement, string: str) -> tuple[MathElement, str]: ... +def handle_script_or_limit( + node: MathElement, c: str, limits: str = "" +) -> munderover | msubsup | munder | msub | mover | msup: ... +def begin_environment(node: MathElement, string: str) -> tuple[mtd, str]: ... +def end_environment(node: MathElement, string: str) -> tuple[MathElement, str]: ... +def tex_equation_columns(rows: Iterable[str]) -> int: ... +def align_attributes(rows: Iterable[str]) -> dict[str, str | bool]: ... +def tex2mathml(tex_math: str, as_block: bool = False) -> str: ... diff --git a/stubs/docutils/docutils/utils/math/math2html.pyi b/stubs/docutils/docutils/utils/math/math2html.pyi new file mode 100644 index 000000000..38fe09051 --- /dev/null +++ b/stubs/docutils/docutils/utils/math/math2html.pyi @@ -0,0 +1,635 @@ +from _typeshed import Incomplete +from collections.abc import Generator +from typing import ClassVar, Final, TextIO, TypeVar + +_T = TypeVar("_T") + +__version__: Final[str] + +class Trace: + debugmode: ClassVar[bool] + quietmode: ClassVar[bool] + showlinesmode: ClassVar[bool] + prefix: ClassVar[str | None] + @classmethod + def debug(cls, message: str) -> None: ... + @classmethod + def message(cls, message: str) -> None: ... + @classmethod + def error(cls, message: str) -> None: ... + @classmethod + def show(cls, message: str, channel: TextIO) -> None: ... + +class ContainerConfig: + extracttext: ClassVar[dict[str, list[str]]] + +class EscapeConfig: + chars: ClassVar[dict[str, str]] + entities: ClassVar[dict[str, str]] + +class FormulaConfig: + alphacommands: ClassVar[dict[str, str]] + array: ClassVar[dict[str, str]] + bigbrackets: ClassVar[dict[str, list[str]]] + bracketcommands: ClassVar[dict[str, str]] + combiningfunctions: ClassVar[dict[str, str]] + commands: ClassVar[dict[str, str]] + cmddict: ClassVar[dict[str, str]] + oversetfunctions: ClassVar[dict[str, str]] + undersetfunctions: ClassVar[dict[str, str]] + endings: ClassVar[dict[str, str]] + environments: ClassVar[dict[str, list[str]]] + fontfunctions: ClassVar[dict[str, str]] + hybridfunctions: ClassVar[dict[str, list[str]]] + hybridsizes: ClassVar[dict[str, str]] + labelfunctions: ClassVar[dict[str, str]] + limitcommands: ClassVar[dict[str, str]] + modified: ClassVar[dict[str, str]] + onefunctions: ClassVar[dict[str, str]] + spacedcommands: ClassVar[dict[str, str]] + starts: ClassVar[dict[str, str]] + symbolfunctions: ClassVar[dict[str, str]] + textfunctions: ClassVar[dict[str, str]] + unmodified: ClassVar[dict[str, list[str]]] + +class CommandLineParser: + options: Incomplete + def __init__(self, options) -> None: ... + def parseoptions(self, args): ... + def readoption(self, args): ... + def readquoted(self, args, initial): ... + def readequalskey(self, arg, args): ... + +class Options: + location: Incomplete + debug: bool + quiet: bool + version: bool + help: bool + simplemath: bool + showlines: bool + branches: Incomplete + def parseoptions(self, args) -> None: ... + def processoptions(self) -> None: ... + def usage(self) -> None: ... + def showoptions(self) -> None: ... + def showversion(self) -> None: ... + +class Cloner: + @classmethod + def clone(cls, original: _T) -> _T: ... + @classmethod + def create(cls, type: type[_T]) -> _T: ... + +class ContainerExtractor: + allowed: Incomplete + extracted: Incomplete + def __init__(self, config) -> None: ... + def extract(self, container): ... + def process(self, container, list) -> None: ... + def safeclone(self, container): ... + +class Parser: + begin: int + parameters: Incomplete + def __init__(self) -> None: ... + def parseheader(self, reader): ... + def parseparameter(self, reader) -> None: ... + def parseending(self, reader, process) -> None: ... + def parsecontainer(self, reader, contents) -> None: ... + +class LoneCommand(Parser): + def parse(self, reader): ... + +class TextParser(Parser): + stack: Incomplete + ending: Incomplete + endings: Incomplete + def __init__(self, container) -> None: ... + def parse(self, reader): ... + def isending(self, reader): ... + +class ExcludingParser(Parser): + def parse(self, reader): ... + +class BoundedParser(ExcludingParser): + def parse(self, reader): ... + +class BoundedDummy(Parser): + def parse(self, reader): ... + +class StringParser(Parser): + begin: Incomplete + def parseheader(self, reader): ... + def parse(self, reader): ... + +class ContainerOutput: + def gethtml(self, container) -> None: ... + def isempty(self): ... + +class EmptyOutput(ContainerOutput): + def gethtml(self, container): ... + def isempty(self): ... + +class FixedOutput(ContainerOutput): + def gethtml(self, container): ... + +class ContentsOutput(ContainerOutput): + def gethtml(self, container): ... + +class TaggedOutput(ContentsOutput): + tag: Incomplete + breaklines: bool + empty: bool + def settag(self, tag, breaklines: bool = False, empty: bool = False): ... + def setbreaklines(self, breaklines): ... + def gethtml(self, container): ... + def open(self, container): ... + def close(self, container): ... + def selfclosing(self, container): ... + def checktag(self, container): ... + +class FilteredOutput(ContentsOutput): + filters: Incomplete + def __init__(self) -> None: ... + def addfilter(self, original, replacement) -> None: ... + def gethtml(self, container): ... + def filter(self, line): ... + +class StringOutput(ContainerOutput): + def gethtml(self, container): ... + +class Globable: + leavepending: bool + endinglist: Incomplete + def __init__(self) -> None: ... + def checkbytemark(self) -> None: ... + def isout(self): ... + def current(self): ... + def checkfor(self, string): ... + def finished(self): ... + def skipcurrent(self): ... + def glob(self, currentcheck): ... + def globalpha(self): ... + def globnumber(self): ... + def isidentifier(self): ... + def globidentifier(self): ... + def isvalue(self): ... + def globvalue(self): ... + def skipspace(self): ... + def globincluding(self, magicchar): ... + def globexcluding(self, excluded): ... + def pushending(self, ending, optional: bool = False) -> None: ... + def popending(self, expected: Incomplete | None = None): ... + def nextending(self): ... + +class EndingList: + endings: Incomplete + def __init__(self) -> None: ... + def add(self, ending, optional: bool = False) -> None: ... + def pickpending(self, pos) -> None: ... + def checkin(self, pos): ... + def pop(self, pos): ... + def findending(self, pos): ... + def checkpending(self) -> None: ... + +class PositionEnding: + ending: Incomplete + optional: Incomplete + def __init__(self, ending, optional) -> None: ... + def checkin(self, pos): ... + +class Position(Globable): + def __init__(self) -> None: ... + def skip(self, string) -> None: ... + def identifier(self): ... + def extract(self, length) -> None: ... + def checkfor(self, string): ... + def checkforlower(self, string): ... + def skipcurrent(self): ... + def __next__(self): ... + def checkskip(self, string): ... + def error(self, message) -> None: ... + +class TextPosition(Position): + pos: int + text: Incomplete + def __init__(self, text) -> None: ... + def skip(self, string) -> None: ... + def identifier(self): ... + def isout(self): ... + def current(self): ... + def extract(self, length): ... + +class Container: + partkey: Incomplete + parent: Incomplete + begin: Incomplete + contents: Incomplete + def __init__(self) -> None: ... + def process(self) -> None: ... + def gethtml(self): ... + def escape(self, line, replacements={"&": "&", "<": "<", ">": ">"}): ... + def escapeentities(self, line): ... + def searchall(self, type): ... + def searchremove(self, type): ... + def searchprocess(self, type, process): ... + def locateprocess(self, locate, process) -> None: ... + def recursivesearch(self, locate, recursive, process) -> None: ... + def extracttext(self): ... + def group(self, index, group, isingroup) -> None: ... + def remove(self, index) -> None: ... + def tree(self, level: int = 0) -> None: ... + def getparameter(self, name): ... + def getparameterlist(self, name): ... + def hasemptyoutput(self): ... + +class BlackBox(Container): + parser: Incomplete + output: Incomplete + contents: Incomplete + def __init__(self) -> None: ... + +class StringContainer(Container): + parsed: Incomplete + parser: Incomplete + output: Incomplete + string: str + def __init__(self) -> None: ... + def process(self) -> None: ... + def replacespecial(self, line): ... + def changeline(self, line): ... + def extracttext(self): ... + +class Constant(StringContainer): + contents: Incomplete + string: Incomplete + output: Incomplete + def __init__(self, text) -> None: ... + +class DocumentParameters: + displaymode: bool + +class FormulaParser(Parser): + begin: Incomplete + def parseheader(self, reader): ... + def parsetype(self, reader): ... + def parse(self, reader): ... + def parseformula(self, reader): ... + def parsesingleliner(self, reader, start, ending): ... + def parsemultiliner(self, reader, start, ending): ... + +class FormulaBit(Container): + type: str | None + size: int + original: str + contents: Incomplete + output: Incomplete + def __init__(self) -> None: ... + factory: Incomplete + def setfactory(self, factory): ... + def add(self, bit) -> None: ... + def skiporiginal(self, string, pos) -> None: ... + def computesize(self): ... + def clone(self): ... + +class TaggedBit(FormulaBit): + output: Incomplete + def constant(self, constant, tag): ... + contents: Incomplete + def complete(self, contents, tag, breaklines: bool = False): ... + def selfcomplete(self, tag): ... + +class FormulaConstant(Constant): + original: Incomplete + size: int + type: str | None + def __init__(self, string) -> None: ... + def computesize(self): ... + def clone(self): ... + +class RawText(FormulaBit): + def detect(self, pos): ... + def parsebit(self, pos) -> None: ... + +class FormulaSymbol(FormulaBit): + modified: Incomplete + unmodified: Incomplete + def detect(self, pos): ... + def parsebit(self, pos) -> None: ... + def addsymbol(self, symbol, pos) -> None: ... + +class FormulaNumber(FormulaBit): + def detect(self, pos): ... + def parsebit(self, pos): ... + +class Comment(FormulaBit): + start: Incomplete + def detect(self, pos): ... + def parsebit(self, pos) -> None: ... + +class WhiteSpace(FormulaBit): + def detect(self, pos): ... + def parsebit(self, pos) -> None: ... + +class Bracket(FormulaBit): + start: Incomplete + ending: Incomplete + inner: Incomplete + def __init__(self) -> None: ... + def detect(self, pos): ... + def parsebit(self, pos): ... + def parsetext(self, pos): ... + def parseliteral(self, pos): ... + def parsecomplete(self, pos, innerparser) -> None: ... + def innerformula(self, pos) -> None: ... + def innertext(self, pos) -> None: ... + literal: str + def innerliteral(self, pos) -> None: ... + +class SquareBracket(Bracket): + start: Incomplete + ending: Incomplete + def clone(self): ... + +class MathsProcessor: + def process(self, contents, index) -> None: ... + +class FormulaProcessor: + processors: Incomplete + def process(self, bit) -> None: ... + def processcontents(self, bit) -> None: ... + def processinsides(self, bit) -> None: ... + def traversewhole(self, formula) -> None: ... + def traverse(self, bit) -> Generator[Incomplete, Incomplete]: ... + def italicize(self, bit, contents) -> None: ... + +class Formula(Container): + parser: Incomplete + output: Incomplete + def __init__(self) -> None: ... + def process(self) -> None: ... + contents: Incomplete + def classic(self) -> None: ... + def parse(self, pos): ... + header: Incomplete + def parsedollarinline(self, pos) -> None: ... + def parsedollarblock(self, pos) -> None: ... + parsed: Incomplete + def parsedollar(self, pos) -> None: ... + def parseinlineto(self, pos, limit) -> None: ... + def parseblockto(self, pos, limit) -> None: ... + def parseupto(self, pos, limit): ... + +class WholeFormula(FormulaBit): + def detect(self, pos): ... + def parsebit(self, pos) -> None: ... + +class FormulaFactory: + types: Incomplete + skippedtypes: Incomplete + defining: bool + instances: Incomplete + def __init__(self) -> None: ... + def detecttype(self, type, pos): ... + def instance(self, type): ... + def create(self, type): ... + def clearskipped(self, pos) -> None: ... + def skipany(self, pos): ... + def parseany(self, pos): ... + def parsetype(self, type, pos): ... + def parseformula(self, formula): ... + +class FormulaCommand(FormulaBit): + types: Incomplete + start: Incomplete + commandmap: ClassVar[dict[str, str] | dict[str, list[str]] | None] + def detect(self, pos): ... + output: Incomplete + def parsebit(self, pos): ... + def parsewithcommand(self, command, pos): ... + def parsecommandtype(self, command, type, pos): ... + def extractcommand(self, pos): ... + def emptycommand(self, pos): ... + def parseupgreek(self, command, pos): ... + +class CommandBit(FormulaCommand): + command: Incomplete + translated: Incomplete + def setcommand(self, command) -> None: ... + def parseparameter(self, pos): ... + def parsesquare(self, pos): ... + def parseliteral(self, pos): ... + def parsesquareliteral(self, pos): ... + def parsetext(self, pos): ... + +class EmptyCommand(CommandBit): + commandmap: ClassVar[dict[str, str]] + contents: Incomplete + def parsebit(self, pos) -> None: ... + +class SpacedCommand(CommandBit): + commandmap: ClassVar[dict[str, str]] + contents: Incomplete + def parsebit(self, pos) -> None: ... + +class AlphaCommand(EmptyCommand): + commandmap: ClassVar[dict[str, str]] + greek_capitals: Incomplete + def parsebit(self, pos) -> None: ... + +class OneParamFunction(CommandBit): + commandmap: ClassVar[dict[str, str]] + simplified: bool + output: Incomplete + def parsebit(self, pos) -> None: ... + html: Incomplete + def simplifyifpossible(self) -> None: ... + +class SymbolFunction(CommandBit): + commandmap: ClassVar[dict[str, str]] + def detect(self, pos): ... + output: Incomplete + def parsebit(self, pos) -> None: ... + +class TextFunction(CommandBit): + commandmap: ClassVar[dict[str, str]] + output: Incomplete + def parsebit(self, pos) -> None: ... + def process(self) -> None: ... + +class FontFunction(OneParamFunction): + commandmap: ClassVar[dict[str, str]] + def process(self) -> None: ... + +class BigBracket: + size: Incomplete + original: Incomplete + alignment: Incomplete + pieces: Incomplete + def __init__(self, size, bracket, alignment: str = "l") -> None: ... + def getpiece(self, index): ... + def getpiece1(self, index): ... + def getpiece3(self, index): ... + def getpiece4(self, index): ... + def getcell(self, index): ... + def getcontents(self): ... + def getsinglebracket(self): ... + +class FormulaEquation(CommandBit): + piece: str + output: Incomplete + def parsebit(self, pos) -> None: ... + +class FormulaCell(FormulaCommand): + alignment: Incomplete + output: Incomplete + def setalignment(self, alignment): ... + def parsebit(self, pos) -> None: ... + +class FormulaRow(FormulaCommand): + cellseparator: Incomplete + alignments: Incomplete + output: Incomplete + def setalignments(self, alignments): ... + def parsebit(self, pos) -> None: ... + def createcell(self, index): ... + +class MultiRowFormula(CommandBit): + rows: Incomplete + size: Incomplete + def parserows(self, pos) -> None: ... + def iteraterows(self, pos) -> Generator[Incomplete]: ... + def addempty(self) -> None: ... + def addrow(self, row) -> None: ... + +class FormulaArray(MultiRowFormula): + piece: str + output: Incomplete + def parsebit(self, pos) -> None: ... + valign: str + alignments: Incomplete + def parsealignments(self, pos) -> None: ... + +class FormulaMatrix(MultiRowFormula): + piece: str + output: Incomplete + valign: str + alignments: Incomplete + def parsebit(self, pos) -> None: ... + +class FormulaCases(MultiRowFormula): + piece: str + output: Incomplete + alignments: Incomplete + contents: Incomplete + def parsebit(self, pos) -> None: ... + +class EquationEnvironment(MultiRowFormula): + output: Incomplete + alignments: Incomplete + def parsebit(self, pos) -> None: ... + +class BeginCommand(CommandBit): + commandmap: ClassVar[dict[str, str]] + types: Incomplete + size: Incomplete + def parsebit(self, pos) -> None: ... + def findbit(self, piece): ... + +class CombiningFunction(OneParamFunction): + commandmap: ClassVar[dict[str, str]] + def parsebit(self, pos) -> None: ... + def parsesingleparameter(self, pos): ... + +class OversetFunction(OneParamFunction): + commandmap: ClassVar[dict[str, str]] + symbol: Incomplete + parameter: Incomplete + output: Incomplete + def parsebit(self, pos) -> None: ... + +class UndersetFunction(OneParamFunction): + commandmap: ClassVar[dict[str, str]] + symbol: Incomplete + parameter: Incomplete + output: Incomplete + def parsebit(self, pos) -> None: ... + +class LimitCommand(EmptyCommand): + commandmap: ClassVar[dict[str, str]] + output: Incomplete + def parsebit(self, pos) -> None: ... + +class LimitPreviousCommand(LimitCommand): + commandmap: ClassVar[None] # type: ignore[assignment] + output: Incomplete + def parsebit(self, pos) -> None: ... + +class LimitsProcessor(MathsProcessor): + def process(self, contents, index) -> None: ... + def checklimits(self, contents, index): ... + def limitsahead(self, contents, index) -> None: ... + def modifylimits(self, contents, index) -> None: ... + def getlimit(self, contents, index): ... + def modifyscripts(self, contents, index) -> None: ... + def checkscript(self, contents, index): ... + def checkcommand(self, contents, index, type): ... + def getscript(self, contents, index): ... + +class BracketCommand(OneParamFunction): + commandmap: ClassVar[dict[str, str]] + def parsebit(self, pos) -> None: ... + original: Incomplete + command: Incomplete + contents: Incomplete + def create(self, direction, character): ... + +class BracketProcessor(MathsProcessor): + def process(self, contents, index): ... + def processleft(self, contents, index) -> None: ... + def checkleft(self, contents, index): ... + def checkright(self, contents, index): ... + def checkdirection(self, bit, command): ... + def findright(self, contents, index): ... + def findmax(self, contents, leftindex, rightindex): ... + def resize(self, command, size) -> None: ... + +class ParameterDefinition: + parambrackets: ClassVar[list[tuple[str, str]]] + name: str + literal: bool + optional: bool + value: Incomplete + literalvalue: Incomplete + def __init__(self) -> None: ... + def parse(self, pos): ... + def read(self, pos, function) -> None: ... + +class ParameterFunction(CommandBit): + params: Incomplete + def readparams(self, readtemplate, pos) -> None: ... + def paramdefs(self, readtemplate) -> Generator[Incomplete]: ... + def getparam(self, name): ... + def getvalue(self, name): ... + def getliteralvalue(self, name): ... + +class HybridFunction(ParameterFunction): + commandmap: ClassVar[dict[str, list[str]]] + contents: Incomplete + def parsebit(self, pos) -> None: ... + def writeparams(self, writetemplate): ... + def writepos(self, pos): ... + def writeparam(self, pos): ... + def writefunction(self, pos): ... + def readtag(self, pos): ... + def writebracket(self, direction, character): ... + size: Incomplete + def computehybridsize(self) -> None: ... + +class HybridSize: + configsizes: ClassVar[dict[str, str]] + def getsize(self, function): ... + +def math2html(formula): ... +def main() -> None: ... diff --git a/stubs/docutils/docutils/utils/math/mathalphabet2unichar.pyi b/stubs/docutils/docutils/utils/math/mathalphabet2unichar.pyi new file mode 100644 index 000000000..15aa3be4e --- /dev/null +++ b/stubs/docutils/docutils/utils/math/mathalphabet2unichar.pyi @@ -0,0 +1,13 @@ +from typing import Final + +mathbb: Final[dict[str, str]] +mathbf: Final[dict[str, str]] +mathbfit: Final[dict[str, str]] +mathcal: Final[dict[str, str]] +mathfrak: Final[dict[str, str]] +mathit: Final[dict[str, str]] +mathsf: Final[dict[str, str]] +mathsfbf: Final[dict[str, str]] +mathsfbfit: Final[dict[str, str]] +mathsfit: Final[dict[str, str]] +mathtt: Final[dict[str, str]] diff --git a/stubs/docutils/docutils/utils/math/mathml_elements.pyi b/stubs/docutils/docutils/utils/math/mathml_elements.pyi new file mode 100644 index 000000000..3f1c4d803 --- /dev/null +++ b/stubs/docutils/docutils/utils/math/mathml_elements.pyi @@ -0,0 +1,82 @@ +import numbers +import xml.etree.ElementTree as ET +from collections.abc import Iterable +from typing import ClassVar, Final, SupportsIndex, overload +from typing_extensions import Self + +GLOBAL_ATTRIBUTES: Final[tuple[str, ...]] + +class MathElement(ET.Element): + nchildren: ClassVar[int | None] + parent: MathElement | None + def __init__(self, *children, **attributes: object) -> None: ... # attributes is passed to self.a_str method + @staticmethod + def a_str(v: object) -> str: ... + def set(self, key: str, value: object) -> None: ... # value is passed to self.a_str method + @overload # type: ignore[override] + def __setitem__(self, key: SupportsIndex, value: MathElement) -> None: ... + @overload # type: ignore[override] + def __setitem__(self, key: slice, value: Iterable[MathElement]) -> None: ... + def is_full(self) -> bool: ... + def close(self) -> MathElement | None: ... + def append(self, element: MathElement) -> Self: ... # type: ignore[override] + def extend(self, elements: Iterable[MathElement]) -> Self: ... # type: ignore[override] + def pop(self, index: int = -1): ... + def in_block(self) -> bool: ... + def indent_xml(self, space: str = " ", level: int = 0) -> None: ... + def unindent_xml(self) -> None: ... + def toxml(self, encoding: str | None = None) -> str: ... + +class MathRow(MathElement): ... + +class MathSchema(MathElement): + nchildren: ClassVar[int] + switch: bool + def __init__(self, *children, switch: bool = False, **kwargs) -> None: ... + +class MathToken(MathElement): + nchildren: ClassVar[int] + text: str + def __init__(self, text: str | numbers.Number, **attributes: object) -> None: ... + +class math(MathRow): ... +class mtext(MathToken): ... +class mi(MathToken): ... +class mn(MathToken): ... +class mo(MathToken): ... + +class mspace(MathElement): + nchildren: ClassVar[int] + +class mrow(MathRow): + def transfer_attributes(self, other) -> None: ... + +class mfrac(MathSchema): ... + +class msqrt(MathRow): + nchildren: ClassVar[int] + +class mroot(MathSchema): ... +class mstyle(MathRow): ... +class merror(MathRow): ... + +class menclose(MathRow): + nchildren: ClassVar[int] + +class mpadded(MathRow): ... + +class mphantom(MathRow): + nchildren: ClassVar[int] + +class msub(MathSchema): ... +class msup(MathSchema): ... + +class msubsup(MathSchema): + nchildren: ClassVar[int] + +class munder(msub): ... +class mover(msup): ... +class munderover(msubsup): ... +class mtable(MathElement): ... +class mtr(MathRow): ... +class mtd(MathRow): ... diff --git a/stubs/docutils/docutils/utils/math/tex2mathml_extern.pyi b/stubs/docutils/docutils/utils/math/tex2mathml_extern.pyi new file mode 100644 index 000000000..d0efc08b1 --- /dev/null +++ b/stubs/docutils/docutils/utils/math/tex2mathml_extern.pyi @@ -0,0 +1,8 @@ +from typing import Final + +document_template: Final[str] + +def blahtexml(math_code: str, as_block: bool = False) -> str: ... +def latexml(math_code: str, as_block: bool = False) -> str: ... +def pandoc(math_code: str, as_block: bool = False) -> str: ... +def ttm(math_code: str, as_block: bool = False) -> str: ... diff --git a/stubs/docutils/docutils/utils/math/tex2unichar.pyi b/stubs/docutils/docutils/utils/math/tex2unichar.pyi new file mode 100644 index 000000000..3cbd0cfbc --- /dev/null +++ b/stubs/docutils/docutils/utils/math/tex2unichar.pyi @@ -0,0 +1,14 @@ +mathaccent: dict[str, str] +mathalpha: dict[str, str] +mathbin: dict[str, str] +mathclose: dict[str, str] +mathfence: dict[str, str] +mathop: dict[str, str] +mathopen: dict[str, str] +mathord: dict[str, str] +mathover: dict[str, str] +mathpunct: dict[str, str] +mathradical: dict[str, str] +mathrel: dict[str, str] +mathunder: dict[str, str] +space: dict[str, str] diff --git a/stubs/docutils/docutils/utils/math/unichar2tex.pyi b/stubs/docutils/docutils/utils/math/unichar2tex.pyi new file mode 100644 index 000000000..3ef39b9d9 --- /dev/null +++ b/stubs/docutils/docutils/utils/math/unichar2tex.pyi @@ -0,0 +1 @@ +uni2tex_table: dict[int, str] diff --git a/stubs/docutils/docutils/utils/punctuation_chars.pyi b/stubs/docutils/docutils/utils/punctuation_chars.pyi new file mode 100644 index 000000000..9d593c137 --- /dev/null +++ b/stubs/docutils/docutils/utils/punctuation_chars.pyi @@ -0,0 +1,9 @@ +from typing import Final + +openers: Final[str] +closers: Final[str] +delimiters: Final[str] +closing_delimiters: Final[str] +quote_pairs: dict[str, str] + +def match_chars(c1: str, c2: str) -> bool: ... diff --git a/stubs/docutils/docutils/utils/roman.pyi b/stubs/docutils/docutils/utils/roman.pyi index 1595a736d..877a52a4a 100644 --- a/stubs/docutils/docutils/utils/roman.pyi +++ b/stubs/docutils/docutils/utils/roman.pyi @@ -1,4 +1,11 @@ +import argparse import re +from typing import Final, Literal + +__author__: Final[str] +__version__: Final[str] +__date__: Final[str] +__copyright__: Final[str] class RomanError(Exception): ... class OutOfRangeError(RomanError): ... @@ -9,6 +16,8 @@ romanNumeralMap: tuple[tuple[str, int], ...] def toRoman(n: int) -> str: ... -romanNumeralPattern: re.Pattern[str] +romanNumeralPattern: Final[re.Pattern[str]] def fromRoman(s: str) -> int: ... +def parse_args() -> argparse.Namespace: ... +def main() -> Literal[0]: ... diff --git a/stubs/docutils/docutils/utils/smartquotes.pyi b/stubs/docutils/docutils/utils/smartquotes.pyi new file mode 100644 index 000000000..1d68592d2 --- /dev/null +++ b/stubs/docutils/docutils/utils/smartquotes.pyi @@ -0,0 +1,44 @@ +from collections.abc import Generator, Iterable +from re import Pattern +from typing import ClassVar, Final, Literal + +options: Final[str] + +class smartchars: + endash: ClassVar[str] + emdash: ClassVar[str] + ellipsis: ClassVar[str] + apostrophe: ClassVar[str] + quotes: ClassVar[dict[str, str | tuple[str, str, str, str]]] + language: str + def __init__(self, language: str = "en") -> None: ... + +class RegularExpressions: + START_SINGLE: ClassVar[Pattern[str]] + START_DOUBLE: ClassVar[Pattern[str]] + ADJACENT_1: ClassVar[Pattern[str]] + ADJACENT_2: ClassVar[Pattern[str]] + OPEN_SINGLE: ClassVar[Pattern[str]] + OPEN_DOUBLE: ClassVar[Pattern[str]] + DECADE: ClassVar[Pattern[str]] + APOSTROPHE: ClassVar[Pattern[str]] + OPENING_SECONDARY: ClassVar[Pattern[str]] + CLOSING_SECONDARY: ClassVar[Pattern[str]] + OPENING_PRIMARY: ClassVar[Pattern[str]] + CLOSING_PRIMARY: ClassVar[Pattern[str]] + +regexes: RegularExpressions +default_smartypants_attr: Final = "1" + +def smartyPants(text: str, attr="1", language: str = "en") -> str: ... +def educate_tokens(text_tokens: Iterable[tuple[str, str]], attr="1", language: str = "en") -> Generator[str]: ... +def educateQuotes(text: str, language: str = "en") -> str: ... +def educateBackticks(text: str, language: str = "en") -> str: ... +def educateSingleBackticks(text: str, language: str = "en") -> str: ... +def educateDashes(text: str) -> str: ... +def educateDashesOldSchool(text: str) -> str: ... +def educateDashesOldSchoolInverted(text: str) -> str: ... +def educateEllipses(text: str) -> str: ... +def stupefyEntities(text: str, language: str = "en") -> str: ... +def processEscapes(text: str, restore: bool = False) -> str: ... +def tokenize(text: str) -> Generator[tuple[Literal["tag", "text"], str]]: ... diff --git a/stubs/docutils/docutils/utils/urischemes.pyi b/stubs/docutils/docutils/utils/urischemes.pyi new file mode 100644 index 000000000..5e6f8a70a --- /dev/null +++ b/stubs/docutils/docutils/utils/urischemes.pyi @@ -0,0 +1 @@ +schemes: dict[str, str]