basedpyright 1.12.4 → 1.12.5

package/dist/typeshed-fallback/stubs/reportlab/reportlab/platypus/para.pyi

@@ -0,0 +1,271 @@
+from _typeshed import Incomplete, Unused
+from collections.abc import Callable, Mapping
+from typing import Any, Final, Literal, Protocol, TypedDict, TypeVar, overload
+from typing_extensions import TypeAlias, Unpack
+
+from reportlab.lib.colors import Color
+from reportlab.lib.styles import ParagraphStyle, PropertySet, StyleSheet1
+from reportlab.pdfgen.canvas import Canvas
+from reportlab.pdfgen.textobject import PDFTextObject, _Color
+from reportlab.platypus.flowables import Flowable
+
+_T = TypeVar("_T")
+_BoolInt: TypeAlias = Literal[0, 1]
+_Op: TypeAlias = _SupportsWidthAndExecute | str | float | tuple[str, Unpack[tuple[Any, ...]]]
+# NOTE: Output from pyRXP xml parser
+_ParsedText: TypeAlias = tuple[str, dict[str, Any], list[_ParsedText], Any] | list[_ParsedText] | str
+
+class _LineOpHandler(Protocol):
+    def start_at(self, x: float, y: float, para: paragraphEngine, canvas: Canvas, textobject: PDFTextObject) -> None: ...
+    def end_at(self, x: float, y: float, para: paragraphEngine, canvas: Canvas, textobject: PDFTextObject) -> None: ...
+
+class _SupportsWidthAndExecute(Protocol):
+    def width(self, engine) -> float: ...
+    def execute(self, engine, textobject: PDFTextObject, canvas: Canvas) -> object: ...
+
+class _SimpleStyleKwargs(TypedDict, total=False):
+    fontName: str
+    fontSize: float
+    leading: float
+    leftIndent: float
+    rightIndent: float
+    firstLineIndent: float
+    alignment: Literal[0, 1, 2, 4]
+    spaceBefore: float
+    spaceAfter: float
+    bulletFontName: str
+    bulletFontSize: float
+    bulletIndent: float
+    textColor: _Color
+    backColor: _Color | None
+
+debug: int
+DUMPPROGRAM: int
+TOOSMALLSPACE: float
+
+class paragraphEngine:
+    TEXT_STATE_VARIABLES: Final[tuple[str, ...]]
+    lineOpHandlers: list[_LineOpHandler]
+    program: list[_Op]
+    indent: float
+    baseindent: float
+    fontName: str
+    fontSize: float
+    leading: float
+    fontColor: _Color
+    x: float
+    y: float
+    alignment: Literal[0, 1, 2, 4]
+    # NOTE: The inner list matches TEXT_STATE_VARIABLES
+    textStateStack: list[list[Any]]
+    def __init__(self, program: list[_Op] | None = None) -> None: ...
+    def pushTextState(self) -> list[Any]: ...
+    def popTextState(self) -> None: ...
+    def format(
+        self, maxwidth: float, maxheight: float, program: list[_Op], leading: float = 0
+    ) -> tuple[list[_Op], str, dict[str, Any], float]: ...
+    def getState(self) -> dict[str, Any]: ...
+    def resetState(self, state: dict[str, Any]) -> None: ...
+    def fitLine(
+        self, program: list[_Op], totalLength: float
+    ) -> tuple[Literal[0, 1], list[_Op], int, float, float, float, Literal[0, 1]]: ...
+    def centerAlign(self, line: list[_Op], lineLength: float, maxLength: float) -> list[_Op]: ...
+    def rightAlign(self, line: list[_Op], lineLength: float, maxLength: float) -> list[_Op]: ...
+    def insertShift(self, line: list[_Op], shift: float) -> list[_Op]: ...
+    def justifyAlign(self, line: list[_Op], lineLength: float, maxLength: float) -> list[_Op]: ...
+    def shrinkWrap(self, line: list[_Op]) -> list[_Op]: ...
+    def cleanProgram(self, line: list[_Op]) -> list[_Op]: ...
+    def runOpCodes(self, program: list[_Op], canvas: Canvas, textobject: PDFTextObject) -> dict[str, Any]: ...
+
+def stringLine(line: list[_Op], length: float) -> list[_Op]: ...
+def simpleJustifyAlign(line: list[_Op], currentLength: float, maxLength: float) -> list[_Op]: ...
+def readBool(text: str) -> _BoolInt: ...
+def readAlignment(text: str) -> Literal[0, 1, 2, 4] | None: ...
+def readLength(text: str) -> float: ...
+@overload
+def lengthSequence(s: str, converter: Callable[[str], float] = ...) -> list[float]: ...
+@overload
+def lengthSequence(s: str, converter: Callable[[str], _T]) -> list[_T]: ...
+def readColor(text: str | None) -> Color | None: ...
+
+class StyleAttributeConverters:
+    fontSize: list[Callable[[str], float]]
+    leading: list[Callable[[str], float]]
+    leftIndent: list[Callable[[str], float]]
+    rightIndent: list[Callable[[str], float]]
+    firstLineIndent: list[Callable[[str], float]]
+    alignment: list[Callable[[str], Literal[0, 1, 2, 4] | None]]
+    spaceBefore: list[Callable[[str], float]]
+    spaceAfter: list[Callable[[str], float]]
+    bulletFontSize: list[Callable[[str], float]]
+    bulletIndent: list[Callable[[str], float]]
+    textColor: list[Callable[[str], Color | None]]
+    backColor: list[Callable[[str], Color | None]]
+
+class SimpleStyle:
+    name: str
+    fontName: str
+    fontSize: float
+    leading: float
+    leftIndent: float
+    rightIndent: float
+    firstLineIndent: float
+    alignment: Literal[0, 1, 2, 4]
+    spaceBefore: float
+    spaceAfter: float
+    bulletFontName: str
+    bulletFontSize: float
+    bulletIndent: float
+    textColor: _Color
+    backColor: _Color | None
+    # NOTE: We are being generous by allowing PropertySet i.e. ParagraphStyle here
+    #       technically SimpleStyle is more strict and doesn't allow string alignments
+    def __init__(self, name: str, parent: SimpleStyle | PropertySet | None = None, **kw: Unpack[_SimpleStyleKwargs]) -> None: ...
+    def addAttributes(self, dictionary: Mapping[str, str | None]) -> None: ...
+
+DEFAULT_ALIASES: Final[dict[str, str]]
+
+class FastPara(Flowable):
+    style: SimpleStyle | ParagraphStyle
+    simpletext: str
+    lines: list[str] | None
+    # NOTE: We are being generous by allowing PropertySet i.e. ParagraphStyle here
+    #       technically SimpleStyle is more strict and doesn't allow string alignments
+    def __init__(self, style: SimpleStyle | PropertySet, simpletext: str) -> None: ...
+    def draw(self) -> None: ...
+
+def defaultContext() -> dict[str, PropertySet]: ...
+def buildContext(stylesheet: StyleSheet1 | None = None) -> dict[str, PropertySet]: ...
+
+class Para(Flowable):
+    baseindent: float
+    context: dict[str, PropertySet]
+    parsedText: _ParsedText
+    bulletText: str | None
+    style1: SimpleStyle | PropertySet
+    program: list[_Op]
+    formattedProgram: list[_Op]
+    remainder: _ParsedText
+    state: dict[str, Any]
+    bold: _BoolInt
+    italic: _BoolInt
+    face: str
+    size: float
+    def __init__(
+        self,
+        # NOTE: We are being generous by allowing PropertySet i.e. ParagraphStyle here
+        #       technically SimpleStyle is more strict and doesn't allow string alignments
+        style: SimpleStyle | PropertySet,
+        parsedText: tuple[Any, ...] | None = None,
+        bulletText: str | None = None,
+        state: dict[str, Any] | None = None,
+        context: dict[str, PropertySet] | None = None,
+        baseindent: float = 0,
+    ) -> None: ...
+    def draw(self) -> None: ...
+    def compileProgram(self, parsedText: _ParsedText, program: list[_Op] | None = None) -> list[_Op]: ...
+    def linearize(self, program: list[_Op] | None = None, parsedText: _ParsedText | None = None) -> None: ...
+    def compileComponent(self, parsedText: _ParsedText, program: list[_Op]) -> None: ...
+    def shiftfont(
+        self, program: list[_Op], face: str | None = None, bold: _BoolInt | None = None, italic: _BoolInt | None = None
+    ): ...
+    def compile_(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_pageNumber(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_b(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_i(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_u(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_sub(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_ul(self, attdict, content, extra, program: list[_Op], tagname: str = "ul") -> None: ...
+    def compile_ol(self, attdict, content, extra, program: list[_Op]): ...
+    def compile_dl(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_super(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_font(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_a(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_link(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_setLink(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_bullet(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def do_bullet(self, text: str, program: list[_Op]) -> None: ...
+    def compile_tt(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_greek(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_evalString(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_name(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_getName(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_seq(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_seqReset(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_seqDefault(self, attdict, content, extra, program: list[_Op]) -> None: ...
+    def compile_para(self, attdict, content, extra, program: list[_Op], stylename: str = "para.defaultStyle") -> None: ...
+
+class bulletMaker:
+    tagname: Literal["ul", "ol", "dl"]
+    style: str
+    typ: str
+    count: int
+    def __init__(self, tagname: Literal["ul", "ol", "dl"], atts, context) -> None: ...
+    def makeBullet(self, atts, bl: str | None = None) -> None: ...
+
+class EvalStringObject:
+    tagname: str
+    attdict: Incomplete
+    content: str
+    context: Incomplete
+    extra: Incomplete
+    op: Incomplete
+    def __init__(self, attdict, content: str, extra, context) -> None: ...
+    def getOp(self, tuple, engine): ...
+    def width(self, engine) -> float: ...
+    def execute(self, engine, textobject: PDFTextObject, canvas: Canvas) -> None: ...
+
+class SeqObject(EvalStringObject): ...
+class NameObject(EvalStringObject): ...
+class SeqDefaultObject(NameObject): ...
+class SeqResetObject(NameObject): ...
+class GetNameObject(EvalStringObject): ...
+
+class PageNumberObject:
+    example: str
+    def __init__(self, example: str = "XXX") -> None: ...
+    def width(self, engine) -> float: ...
+    def execute(self, engine, textobject: PDFTextObject, canvas: Canvas) -> None: ...
+
+def EmbedInRml2pdf() -> None: ...
+def handleSpecialCharacters(engine, text: str, program: list[_Op] | None = None) -> list[_Op]: ...
+def Paragraph(
+    text: str,
+    style: SimpleStyle | PropertySet,
+    bulletText: str | None = None,
+    frags: Unused | None = None,
+    context: dict[str, PropertySet] | None = None,
+) -> Para | FastPara: ...
+
+class UnderLineHandler:
+    color: _Color | None
+    # NOTE: available after start_at
+    xStart: float
+    yStart: float
+    def __init__(self, color: _Color | None = None) -> None: ...
+    def start_at(self, x: float, y: float, para: paragraphEngine, canvas: Canvas, textobject: PDFTextObject) -> None: ...
+    def end_at(self, x: float, y: float, para: paragraphEngine, canvas: Canvas, textobject: PDFTextObject) -> None: ...
+
+UNDERLINE: Final[UnderLineHandler]
+
+class HotLink(UnderLineHandler):
+    url: str
+    def __init__(self, url: str) -> None: ...
+    def link(self, rect, canvas: Canvas) -> None: ...
+
+class InternalLink(HotLink): ...
+
+class DefDestination(HotLink):
+    defined: _BoolInt
+
+def splitspace(text: str) -> list[str]: ...
+
+testparagraph: str
+testparagraph1: str
+
+def test2(canv, testpara) -> None: ...
+
+testlink: Incomplete
+test_program: Incomplete
+
+def test() -> None: ...

package/dist/typeshed-fallback/stubs/reportlab/reportlab/platypus/paragraph.pyi

@@ -0,0 +1,38 @@
+from reportlab.lib.abag import ABag
+from reportlab.lib.styles import ParagraphStyle, PropertySet
+from reportlab.pdfgen.textobject import PDFTextObject
+from reportlab.platypus.flowables import Flowable
+from reportlab.platypus.paraparser import ParaFrag
+
+class ParaLines(ABag): ...
+class FragLine(ABag): ...
+
+def cleanBlockQuotedText(text: str, joiner: str = " ") -> str: ...
+
+class Paragraph(Flowable):
+    text: str
+    frags: list[ParaFrag]
+    style: ParagraphStyle
+    bulletText: str | None
+    caseSensitive: int
+    encoding: str
+    def __init__(
+        self,
+        text: str,
+        # NOTE: This should be a ParagraphStyle
+        style: PropertySet | None = None,
+        bulletText: str | None = None,
+        frags: list[ParaFrag] | None = None,
+        caseSensitive: int = 1,
+        encoding: str = "utf8",
+    ) -> None: ...
+    def minWidth(self) -> float: ...
+    def draw(self) -> None: ...
+    def breakLines(self, width: float | list[float] | tuple[float, ...]) -> ParaLines | ParaFrag: ...
+    def breakLinesCJK(self, maxWidths: float | list[float] | tuple[float, ...]) -> ParaLines | ParaFrag: ...
+    def beginText(self, x: float, y: float) -> PDFTextObject: ...
+    def drawPara(self, debug: int = 0) -> None: ...
+    def getPlainText(self, identify: bool | None = None) -> str: ...
+    def getActualLineWidths0(self) -> list[float]: ...
+    @staticmethod
+    def dumpFrags(frags, indent: int = 4, full: bool = False) -> str: ...

package/dist/typeshed-fallback/stubs/reportlab/reportlab/platypus/paraparser.pyi

@@ -0,0 +1,117 @@
+from _typeshed import Incomplete
+from html.parser import HTMLParser
+
+from reportlab.lib.abag import ABag
+
+__all__ = ("ParaFrag", "ParaParser")
+
+class _PCT(float):
+    def __new__(cls, v): ...
+    def normalizedValue(self, normalizer): ...
+    def __copy__(self): ...
+    def __deepcopy__(self, mem): ...
+
+class _ExValidate:
+    tag: Incomplete
+    attr: Incomplete
+    def __init__(self, tag, attr) -> None: ...
+    def invalid(self, s) -> None: ...
+    def validate(self, parser, s): ...
+    def __call__(self, parser, s): ...
+
+class _CheckSup(_ExValidate):
+    fontSize: Incomplete
+    def validate(self, parser, s): ...
+    def __call__(self, parser, s): ...
+
+class _CheckUS(_ExValidate):
+    def validate(self, parser, s): ...
+
+class ParaFrag(ABag): ...
+
+class ParaParser(HTMLParser):
+    def __getattr__(self, attrName): ...
+    def start_b(self, attributes) -> None: ...
+    def end_b(self) -> None: ...
+    def start_strong(self, attributes) -> None: ...
+    def end_strong(self) -> None: ...
+    def start_i(self, attributes) -> None: ...
+    def end_i(self) -> None: ...
+    def start_em(self, attributes) -> None: ...
+    def end_em(self) -> None: ...
+    def start_u(self, attributes) -> None: ...
+    def end_u(self) -> None: ...
+    def start_strike(self, attributes) -> None: ...
+    def end_strike(self) -> None: ...
+    def start_link(self, attributes) -> None: ...
+    def end_link(self) -> None: ...
+    def start_a(self, attributes) -> None: ...
+    def end_a(self) -> None: ...
+    def start_img(self, attributes) -> None: ...
+    def end_img(self) -> None: ...
+    def start_super(self, attributes) -> None: ...
+    def end_super(self) -> None: ...
+    start_sup = start_super
+    end_sup = end_super
+    def start_sub(self, attributes) -> None: ...
+    def end_sub(self) -> None: ...
+    def start_nobr(self, attrs) -> None: ...
+    def end_nobr(self) -> None: ...
+    def handle_charref(self, name) -> None: ...
+    def syntax_error(self, lineno, message) -> None: ...
+    def start_greek(self, attr) -> None: ...
+    def end_greek(self) -> None: ...
+    def start_unichar(self, attr) -> None: ...
+    def end_unichar(self) -> None: ...
+    def start_font(self, attr) -> None: ...
+    def end_font(self) -> None: ...
+    def start_span(self, attr) -> None: ...
+    def end_span(self) -> None: ...
+    def start_br(self, attr) -> None: ...
+    def end_br(self) -> None: ...
+    def start_para(self, attr) -> None: ...
+    def end_para(self) -> None: ...
+    bFragList: Incomplete
+    def start_bullet(self, attr) -> None: ...
+    def end_bullet(self) -> None: ...
+    def start_seqdefault(self, attr) -> None: ...
+    def end_seqdefault(self) -> None: ...
+    def start_seqreset(self, attr) -> None: ...
+    def end_seqreset(self) -> None: ...
+    def start_seqchain(self, attr) -> None: ...
+    end_seqchain = end_seqreset
+    def start_seqformat(self, attr) -> None: ...
+    end_seqformat = end_seqreset
+    start_seqDefault = start_seqdefault
+    end_seqDefault = end_seqdefault
+    start_seqReset = start_seqreset
+    end_seqReset = end_seqreset
+    start_seqChain = start_seqchain
+    end_seqChain = end_seqchain
+    start_seqFormat = start_seqformat
+    end_seqFormat = end_seqformat
+    def start_seq(self, attr) -> None: ...
+    def end_seq(self) -> None: ...
+    def start_ondraw(self, attr) -> None: ...
+    start_onDraw = start_ondraw
+    end_onDraw = end_seq
+    end_ondraw = end_seq
+    def start_index(self, attr) -> None: ...
+    end_index = end_seq
+    def start_unknown(self, attr) -> None: ...
+    end_unknown = end_seq
+    def getAttributes(self, attr, attrMap): ...
+    verbose: Incomplete
+    caseSensitive: Incomplete
+    ignoreUnknownTags: Incomplete
+    def __init__(
+        self, verbose: int = 0, caseSensitive: int = 0, ignoreUnknownTags: int = 1, crashOnError: bool = True
+    ) -> None: ...
+    def handle_data(self, data) -> None: ...
+    def handle_cdata(self, data) -> None: ...
+    def tt_parse(self, tt, style): ...
+    def findSpanStyle(self, style) -> None: ...
+    def parse(self, text, style): ...
+    def handle_starttag(self, tag, attrs) -> None: ...
+    def handle_endtag(self, tag) -> None: ...
+    def handle_entityref(self, name) -> None: ...

package/dist/typeshed-fallback/stubs/reportlab/reportlab/platypus/tableofcontents.pyi

@@ -0,0 +1,108 @@
+from _typeshed import Unused
+from collections.abc import Callable, Iterable, Sequence
+from typing import Any, Final, Literal, TypedDict, TypeVar, overload
+from typing_extensions import TypeAlias, Unpack
+
+from reportlab.lib.styles import ParagraphStyle, PropertySet
+from reportlab.pdfgen.canvas import Canvas
+from reportlab.platypus.doctemplate import IndexingFlowable, _CanvasMaker
+from reportlab.platypus.tables import TableStyle
+
+_T = TypeVar("_T")
+_Entry: TypeAlias = tuple[int, str, int] | tuple[int, str, int, str | None] | Sequence[int | str | None]
+_SequencerFormat: TypeAlias = Literal["I", "i", "123", "ABC", "abc"]
+
+class _TableOfContentsKwargs(TypedDict, total=False):
+    rightColumnWidth: float
+    levelStyles: list[PropertySet]  # should be ParagraphStyle
+    tableStyle: TableStyle
+    dotsMinLevel: int
+    formatter: Callable[[int], str] | None
+
+class _SimpleIndexKwargs(TypedDict, total=False):
+    style: Iterable[PropertySet] | PropertySet | None  # should be ParagraphStyle
+    dot: str | None
+    tableStyle: TableStyle | None
+    headers: bool
+    name: str | None
+    format: _SequencerFormat
+    offset: int
+
+__version__: Final[str]
+
+def unquote(txt: str) -> str: ...
+def drawPageNumbers(
+    canvas: Canvas,
+    style: PropertySet,  # should be ParagraphStyle
+    pages: Iterable[tuple[int | str, Unused]],
+    availWidth: float,
+    availHeight: float,
+    dot: str = " . ",
+    formatter: Unused | None = None,
+) -> None: ...
+
+delta: float
+epsilon: float
+defaultLevelStyles: list[ParagraphStyle]
+defaultTableStyle: TableStyle
+
+class TableOfContents(IndexingFlowable):
+    rightColumnWidth: float
+    levelStyles: list[ParagraphStyle]
+    tableStyle: TableStyle
+    dotsMinLevel: int
+    formatter: Callable[[int], str] | None
+    def __init__(self, **kwds: Unpack[_TableOfContentsKwargs]) -> None: ...
+    def isIndexing(self) -> Literal[1]: ...
+    def isSatisfied(self) -> bool: ...
+    def clearEntries(self) -> None: ...
+    def getLevelStyle(self, n: int) -> ParagraphStyle: ...
+    def addEntry(self, level: int, text: str, pageNum: int, key: str | None = None) -> None: ...
+    def addEntries(self, listOfEntries: Iterable[_Entry]) -> None: ...
+
+@overload
+def makeTuple(x: tuple[_T, ...]) -> tuple[_T, ...]: ...
+@overload
+def makeTuple(x: list[_T]) -> tuple[_T, ...]: ...
+@overload
+def makeTuple(x: _T) -> tuple[_T, ...]: ...
+
+class SimpleIndex(IndexingFlowable):
+    # NOTE: Will be a list after getLevelStyle is called
+    textStyle: ParagraphStyle | Iterable[ParagraphStyle] | list[ParagraphStyle]
+    tableStyle: TableStyle
+    dot: str | None
+    headers: bool
+    name: str
+    formatFunc: Callable[[int], str]
+    offset: float
+    def __init__(self, **kwargs: Unpack[_SimpleIndexKwargs]) -> None: ...
+    def getFormatFunc(self, formatName): ...
+    def setup(
+        self,
+        style: PropertySet | None = None,  # should be ParagraphStyle
+        dot: str | None = None,
+        tableStyle: TableStyle | None = None,
+        headers: bool = True,
+        name: str | None = None,
+        format: _SequencerFormat = "123",
+        offset: float = 0,
+    ) -> None: ...
+    def __call__(self, canv: Canvas, kind: str | None, label: str) -> None: ...
+    def getCanvasMaker(self, canvasmaker: _CanvasMaker = ...) -> _CanvasMaker: ...
+    def isIndexing(self) -> Literal[1]: ...
+    def isSatisfied(self) -> bool: ...
+    def clearEntries(self) -> None: ...
+    def addEntry(self, text: str, pageNum: tuple[int, str], key: str | None = None) -> None: ...
+    def draw(self) -> None: ...
+    def getLevelStyle(self, n: int) -> ParagraphStyle: ...
+
+AlphabeticIndex = SimpleIndex
+
+def listdiff(l1: list[Any], l2: list[_T]) -> tuple[int, list[_T]]: ...
+
+class ReferenceText(IndexingFlowable):
+    textPattern: str
+    target: str
+    paraStyle: ParagraphStyle
+    def __init__(self, textPattern: str, targetKey: str) -> None: ...

package/dist/typeshed-fallback/stubs/reportlab/reportlab/platypus/tables.pyi

@@ -0,0 +1,124 @@
+from _typeshed import Incomplete
+from abc import abstractmethod
+from collections.abc import Collection, Iterable, Sequence
+from typing import Any, Literal, overload
+from typing_extensions import TypeAlias, Unpack
+
+from reportlab.lib.colors import Color
+from reportlab.lib.styles import PropertySet
+from reportlab.lib.utils import _UNSET_
+from reportlab.platypus.flowables import Flowable, _HAlignment, _VAlignment
+
+__all__ = ("Table", "TableStyle", "CellStyle", "LongTable")
+
+_Color: TypeAlias = Color | list[float] | tuple[float, float, float, float] | tuple[float, float, float] | str | int
+# TODO: consider creating a tagged union of all the possible commands, although
+#       this would restrict us to passing cmds to TableStyle.__init__ in a tuple
+#       since a list would not be able to be inferred correctly
+#       All commands are a tuple with a str opcode as the first element, followed
+#       by the arguments for that command. Most commands start with two positions
+#       indicating the cell-range affected by the command, the only exception is
+#       the ROUNDEDCORNERS command which applies to the whole table always.
+_SpecialRow: TypeAlias = Literal["splitfirst", "splitlast", "inrowsplitstart", "inrowsplitend"]
+_TableSectionCommand: TypeAlias = tuple[str, tuple[int | _SpecialRow, int], tuple[int, int], Unpack[tuple[Any, ...]]]
+_CornerRadii: TypeAlias = tuple[float, float, float, float] | list[float]
+_RoundedCornersTableCommand: TypeAlias = tuple[Literal["ROUNDEDCORNERS"], _CornerRadii | None]
+_TableCommand: TypeAlias = _TableSectionCommand | _RoundedCornersTableCommand
+
+class CellStyle(PropertySet):
+    name: str
+    fontname: str
+    fontsize: float
+    leading: float
+    leftPadding: float
+    rightPadding: float
+    topPadding: float
+    bottomPadding: float
+    firstLineIndent: float
+    color: _Color
+    alignment: Literal["LEFT", "CENTER", "CENTRE", "RIGHT", "DECIMAL"]
+    background: _Color
+    valign: Literal["TOP", "MIDDLE", "BOTTOM"]
+    href: str | None
+    destination: Incomplete
+    def __init__(self, name: str, parent: CellStyle | None = None) -> None: ...
+    def copy(self, result: CellStyle | None = None) -> CellStyle: ...
+
+class TableStyle:
+    # TODO: Add TypedDict for Table properties that can be set through the style
+    def __init__(self, cmds: Iterable[_TableCommand] | None = None, parent: TableStyle | None = None, **kw) -> None: ...
+    @overload
+    def add(self, *cmd: Unpack[_TableSectionCommand]) -> None: ...
+    @overload
+    def add(self, *cmd: Unpack[_RoundedCornersTableCommand]) -> None: ...
+    def getCommands(self) -> list[_TableCommand]: ...
+
+class Table(Flowable):
+    ident: str | None
+    repeatRows: int
+    repeatCols: int
+    splitByRow: int
+    splitInRow: int
+    spaceBefore: float
+    spaceAfter: float
+    def __init__(
+        self,
+        # NOTE: Technically only list or tuple works but lack of covariance
+        #       on list makes this too annoying
+        data: Sequence[list[Any] | tuple[Any, ...]],
+        colWidths: Sequence[float | str | None] | float | str | None = None,
+        rowHeights: Sequence[float | None] | float | None = None,
+        style: TableStyle | Iterable[_TableCommand] | None = None,
+        # docs say list/tuple, but the implementation allows any collection
+        repeatRows: int | Collection[int] = 0,
+        repeatCols: int | Collection[int] = 0,
+        splitByRow: int = 1,
+        splitInRow: int = 0,
+        emptyTableAction: Literal["error", "indicate", "ignore"] | None = None,
+        ident: str | None = None,
+        hAlign: _HAlignment | None = None,
+        vAlign: _VAlignment | None = None,
+        normalizedData: int = 0,
+        cellStyles: Sequence[Sequence[CellStyle]] | None = None,
+        rowSplitRange: tuple[int, int] | None = None,
+        spaceBefore: float | None = None,
+        spaceAfter: float | None = None,
+        longTableOptimize: Incomplete | None = None,
+        minRowHeights: Sequence[float] | None = None,
+        cornerRadii: _CornerRadii | _UNSET_ | None = ...,
+        renderCB: TableRenderCB | None = None,
+    ) -> None: ...
+    def identity(self, maxLen: int | None = 30) -> str: ...
+    def normalizeData(self, data: Iterable[Iterable[Any]]) -> list[list[Any]]: ...
+    def minWidth(self) -> float: ...
+    def setStyle(self, tblstyle: TableStyle | Iterable[_TableCommand]) -> None: ...
+    def normCellRange(self, sc: int, ec: int, sr: int, er: int) -> tuple[int, int, int, int]: ...
+    def onSplit(self, T: Table, byRow: int = 1) -> None: ...
+    def draw(self) -> None: ...
+
+class LongTable(Table): ...
+
+class TableRenderCB:
+    def __call__(self, T: Table, cmd: str, *args: Any) -> None: ...
+    @abstractmethod
+    def startTable(self, T: Table) -> None: ...
+    @abstractmethod
+    def startBG(self, T: Table) -> None: ...
+    @abstractmethod
+    def endBG(self, T: Table) -> None: ...
+    @abstractmethod
+    def startRow(self, T: Table, rowNo: int) -> None: ...
+    @abstractmethod
+    def startCell(
+        self, T: Table, rowNo: int, colNo: int, cellval: Any, cellstyle: CellStyle, pos: tuple[int, int], size: tuple[int, int]
+    ) -> None: ...
+    @abstractmethod
+    def endCell(self, T: Table) -> None: ...
+    @abstractmethod
+    def endRow(self, T: Table) -> None: ...
+    @abstractmethod
+    def startLines(self, T: Table) -> None: ...
+    @abstractmethod
+    def endLines(self, T: Table) -> None: ...
+    @abstractmethod
+    def endTable(self, T: Table) -> None: ...

package/dist/typeshed-fallback/stubs/reportlab/reportlab/platypus/xpreformatted.pyi

@@ -0,0 +1,30 @@
+from reportlab.lib.styles import PropertySet
+from reportlab.platypus.paragraph import Paragraph, ParaLines
+from reportlab.platypus.paraparser import ParaFrag
+
+class XPreformatted(Paragraph):
+    def __init__(
+        self,
+        text: str,
+        # NOTE: This should be a ParagraphStyle
+        style: PropertySet,
+        bulletText: str | None = None,
+        frags: list[ParaFrag] | None = None,
+        caseSensitive: int = 1,
+        dedent: int = 0,
+    ) -> None: ...
+    def breakLinesCJK(self, width: float | list[float] | tuple[float, ...]) -> ParaLines | ParaFrag: ...
+
+class PythonPreformatted(XPreformatted):
+    formats: dict[str, tuple[str, str]]
+    def __init__(
+        self,
+        text: str,
+        # NOTE: This should be a ParagraphStyle
+        style: PropertySet,
+        bulletText: str | None = None,
+        dedent: int = 0,
+        frags: list[ParaFrag] | None = None,
+    ) -> None: ...
+    def escapeHtml(self, text: str) -> str: ...
+    def fontify(self, code: str) -> str: ...