Bump reportlab to 4.4.* (#13857)

Author: donbarbos

stubs/reportlab/@tests/stubtest_allowlist.txt

@@ -20,7 +20,6 @@ reportlab.graphics.shapes.Drawing.wrap
 reportlab\.platypus\.(doctemplate\.|flowables\.|tableofcontents\.)?[A-Za-z_]+\.split
 reportlab\.platypus\.(doctemplate\.|flowables\.|tableofcontents\.)?[A-Za-z_]+\.wrap
 reportlab.platypus.multicol.MultiCol.split
-reportlab.platypus.multicol.MultiCol.wrap
 reportlab.platypus.para.FastPara.split
 reportlab.platypus.para.FastPara.wrap
 reportlab.platypus.para.Para.split

stubs/reportlab/METADATA.toml

@@ -1,4 +1,4 @@
-version = "4.3.1"
+version = "4.4.*"
 # GitHub mirror of https://hg.reportlab.com/hg-public/reportlab/file
 upstream_repository = "https://github.com/MrBitBucket/reportlab-mirror"
 

stubs/reportlab/reportlab/graphics/renderPM.pyi

@@ -50,9 +50,20 @@ class PMCanvas:
     def fillstrokepath(self, stroke: int = 1, fill: int = 1) -> None: ...
     def bezierArcCCW(self, cx, cy, rx, ry, theta0, theta1): ...
     def addEllipsoidalArc(self, cx, cy, rx, ry, ang1, ang2) -> None: ...
-    def drawCentredString(self, x, y, text, text_anchor: str = "middle") -> None: ...
-    def drawRightString(self, text, x, y) -> None: ...
-    def drawString(self, x, y, text, _fontInfo: Incomplete | None = None, text_anchor: str = "left") -> None: ...
+    def drawCentredString(
+        self, x: float, y: float, text: str, text_anchor: str = "middle", direction: str | None = None, shaping: bool = False
+    ) -> None: ...
+    def drawRightString(self, text: str, x: float, y: float, direction: str | None = None) -> None: ...
+    def drawString(
+        self,
+        x: float,
+        y: float,
+        text: str,
+        _fontInfo: Incomplete | None = None,
+        text_anchor: str = "left",
+        direction: str | None = None,
+        shaping: bool = False,
+    ) -> None: ...
     def line(self, x1, y1, x2, y2) -> None: ...
     def rect(self, x, y, width, height, stroke: int = 1, fill: int = 1) -> None: ...
     def roundRect(self, x, y, width, height, rx, ry) -> None: ...
@@ -73,7 +84,6 @@ class PMCanvas:
     strokeWidth: Incomplete
     def setLineWidth(self, width) -> None: ...
     def stringWidth(self, text, fontName: Incomplete | None = None, fontSize: Incomplete | None = None): ...
-    def shapedText(self, text) -> tuple[Incomplete, Incomplete]: ...
 
 def drawToPMCanvas(
     d: Drawing,

stubs/reportlab/reportlab/lib/rl_accel.pyi

@@ -1,14 +1,16 @@
+from typing import Literal
+
 def fp_str(*a): ...
 def unicode2T1(utext, fonts): ...
-def instanceStringWidthT1(self, text, size, encoding: str = "utf8"): ...
-def instanceStringWidthTTF(self, text, size, encoding: str = "utf8"): ...
-def hex32(i): ...
-def add32(x, y): ...
-def calcChecksum(data): ...
+def instanceStringWidthT1(self, text: str, size: float, encoding: str = "utf8") -> float: ...
+def instanceStringWidthTTF(self, text: str, size: float, encoding: str = "utf8") -> float: ...
+def hex32(i) -> str: ...
+def add32(x: int, y: int) -> int: ...
+def calcChecksum(data: str | bytes) -> int: ...
 def escapePDF(s): ...
-def asciiBase85Encode(input): ...
+def asciiBase85Encode(input: str) -> str: ...
 def asciiBase85Decode(input): ...
-def sameFrag(f, g): ...
+def sameFrag(f, g) -> bool | Literal[0]: ...
 
 __all__ = [
     "fp_str",

stubs/reportlab/reportlab/lib/utils.pyi

@@ -1,7 +1,10 @@
 import datetime
+import zipimport
 from _typeshed import Incomplete, SupportsItems
-from collections.abc import Generator
-from typing import Final, Literal, TypeVar
+from collections.abc import Generator, Iterable
+from os import PathLike
+from types import TracebackType
+from typing import AnyStr, Final, Literal, TypeVar, overload
 
 from reportlab.lib.rltempfile import get_rl_tempdir as get_rl_tempdir, get_rl_tempfile as get_rl_tempfile
 
@@ -24,37 +27,37 @@ __UNSET__: Final[_UNSET_]
 
 isPyPy: bool
 
-def isFunction(v): ...
-def isMethod(v, mt=...): ...
-def isModule(v): ...
-def isSeq(v, _st=...): ...
-def isNative(v): ...
-
-strTypes: Incomplete
-
-def asBytes(v, enc: str = "utf8"): ...
-def asUnicode(v, enc: str = "utf8"): ...
-def asUnicodeEx(v, enc: str = "utf8"): ...
-def asNative(v, enc: str = "utf8"): ...
-def int2Byte(i): ...
-def isStr(v): ...
-def isBytes(v): ...
-def isUnicode(v): ...
-def isClass(v): ...
-def isNonPrimitiveInstance(x): ...
-def instantiated(v): ...
-def bytestr(x, enc: str = "utf8"): ...
-def encode_label(args): ...
-def decode_label(label): ...
-def rawUnicode(s): ...
-def rawBytes(s): ...
-
-rl_exec: Incomplete
-
-def char2int(s): ...
-def rl_reraise(t, v, b: Incomplete | None = None) -> None: ...
+def isFunction(v: object) -> bool: ...
+def isMethod(v: object, mt=...) -> bool: ...
+def isModule(v: object) -> bool: ...
+def isSeq(v: object, _st=...) -> bool: ...
+def isNative(v: object) -> bool: ...
+
+strTypes: tuple[type[str], type[bytes]]
+
+def asBytes(v: str | bytes, enc: str = "utf8") -> bytes: ...
+def asUnicode(v: str | bytes, enc: str = "utf8") -> str: ...
+def asUnicodeEx(v: str | bytes, enc: str = "utf8") -> str: ...
+def asNative(v: str | bytes, enc: str = "utf8") -> str: ...
+def int2Byte(i: int) -> bytes: ...
+def isStr(v: object) -> bool: ...
+def isBytes(v: object) -> bool: ...
+def isUnicode(v: object) -> bool: ...
+def isClass(v: object) -> bool: ...
+def isNonPrimitiveInstance(x: object) -> bool: ...
+def instantiated(v: object) -> bool: ...
+def bytestr(x: object, enc: str = "utf8") -> bytes: ...
+def encode_label(args) -> str: ...
+def decode_label(label: str): ...
+def rawUnicode(s: str | bytes) -> str: ...
+def rawBytes(s: str | bytes) -> bytes: ...
+
+rl_exec = exec
+
+def char2int(s: int | str | bytes) -> int: ...
+def rl_reraise(t, v: BaseException, b: TracebackType | None = None) -> None: ...
 def rl_add_builtins(**kwd) -> None: ...
-def zipImported(ldr: Incomplete | None = None): ...
+def zipImported(ldr: zipimport.zipimporter | None = None) -> zipimport.zipimporter | None: ...
 
 class CIDict(dict[_KT, _VT]):
     def __init__(self, *args, **kwds) -> None: ...
@@ -64,14 +67,14 @@ def markfilename(filename, creatorcode: Incomplete | None = None, filetype: Inco
 
 __rl_loader__: Incomplete
 
-def rl_glob(pattern, glob=...): ...
-def isFileSystemDistro(): ...
-def isCompactDistro(): ...
-def isSourceDistro(): ...
-def normalize_path(p): ...
+def rl_glob(pattern: AnyStr, glob=...) -> list[AnyStr]: ...
+def isFileSystemDistro() -> bool: ...
+def isCompactDistro() -> bool: ...
+def isSourceDistro() -> bool: ...
+def normalize_path(p: PathLike[AnyStr]) -> PathLike[AnyStr]: ...
 def recursiveImport(modulename, baseDir: Incomplete | None = None, noCWD: int = 0, debug: int = 0): ...
 
-haveImages: Incomplete
+haveImages: Final[bool]
 
 class ArgvDictValue:
     value: Incomplete
@@ -147,15 +150,18 @@ class _FmtSelfDict:
 
 class FmtSelfDict: ...
 
-def simpleSplit(text, fontName, fontSize, maxWidth): ...
-def escapeTextOnce(text): ...
+def simpleSplit(text: str | bytes, fontName: str | None, fontSize: float, maxWidth: float | None): ...
+@overload
+def escapeTextOnce(text: None) -> None: ...
+@overload
+def escapeTextOnce(text: str | bytes) -> str: ...
 def fileName2FSEnc(fn): ...
 def prev_this_next(items): ...
-def commasplit(s): ...
-def commajoin(l): ...
+def commasplit(s: str | bytes) -> list[str]: ...
+def commajoin(l: Iterable[str | bytes]) -> str: ...
 def findInPaths(fn, paths, isfile: bool = True, fail: bool = False): ...
-def annotateException(msg, enc: str = "utf8", postMsg: str = "", sep: str = " ") -> None: ...
-def escapeOnce(data): ...
+def annotateException(msg: str, enc: str = "utf8", postMsg: str = "", sep: str = " ") -> None: ...
+def escapeOnce(data: str) -> str: ...
 
 class IdentStr(str):
     def __new__(cls, value): ...
@@ -188,3 +194,12 @@ def recursiveGetAttr(obj, name, g: Incomplete | None = None): ...
 def recursiveSetAttr(obj, name, value) -> None: ...
 def recursiveDelAttr(obj, name) -> None: ...
 def yieldNoneSplits(L) -> Generator[Incomplete, None, None]: ...
+
+class KlassStore:
+    lim: int
+    store: dict[str, type]
+    def __init__(self, lim: int = 127) -> None: ...
+    def add(self, k: str, v: type) -> None: ...
+    def __contains__(self, k) -> bool: ...
+    def __getitem__(self, k: str) -> type: ...
+    def get(self, k, default=None): ...

stubs/reportlab/reportlab/pdfbase/pdfmetrics.pyi

@@ -1,4 +1,4 @@
-from _typeshed import Incomplete
+from _typeshed import Incomplete, StrOrBytesPath
 from typing import Final
 
 from reportlab.lib.rl_accel import unicode2T1 as unicode2T1
@@ -10,7 +10,7 @@ standardEncodings: Incomplete
 class FontError(Exception): ...
 class FontNotFoundError(Exception): ...
 
-def parseAFMFile(afmFileName): ...
+def parseAFMFile(afmFileName: StrOrBytesPath) -> tuple[dict[Incomplete, Incomplete], list[Incomplete]]: ...
 
 class TypeFace:
     name: Incomplete
@@ -51,15 +51,15 @@ class Font:
     encoding: Incomplete
     encName: Incomplete
     substitutionFonts: Incomplete
-    isShaped: bool
+    shapable: bool
     def __init__(self, name, faceName, encName, substitutionFonts: Incomplete | None = None) -> None: ...
-    def stringWidth(self, text, size, encoding: str = "utf8"): ...
+    def stringWidth(self, text: str | bytes, size: float, encoding: str = "utf8") -> float: ...
     def addObjects(self, doc) -> None: ...
 
-PFB_MARKER: Incomplete
-PFB_ASCII: Incomplete
-PFB_BINARY: Incomplete
-PFB_EOF: Incomplete
+PFB_MARKER: Final[str]
+PFB_ASCII: Final[str]
+PFB_BINARY: Final[str]
+PFB_EOF: Final[str]
 
 class EmbeddedType1Face(TypeFace):
     afmFileName: Incomplete
@@ -81,13 +81,13 @@ def registerFontFamily(
 def registerFont(font) -> None: ...
 def getTypeFace(faceName): ...
 def getEncoding(encName): ...
-def findFontAndRegister(fontName): ...
-def getFont(fontName): ...
-def getAscentDescent(fontName, fontSize: Incomplete | None = None): ...
-def getAscent(fontName, fontSize: Incomplete | None = None): ...
-def getDescent(fontName, fontSize: Incomplete | None = None): ...
-def getRegisteredFontNames(): ...
-def stringWidth(text, fontName, fontSize, encoding: str = "utf8"): ...
+def findFontAndRegister(fontName: str) -> Font: ...
+def getFont(fontName: str) -> Font: ...
+def getAscentDescent(fontName: str, fontSize: float | None = None): ...
+def getAscent(fontName: str, fontSize: float | None = None): ...
+def getDescent(fontName: str, fontSize: float | None = None): ...
+def getRegisteredFontNames() -> list[Incomplete]: ...
+def stringWidth(text: str | bytes, fontName: str, fontSize: float, encoding: str = "utf8") -> float: ...
 def dumpFontData() -> None: ...
 def test3widths(texts) -> None: ...
 def testStringWidthAlgorithms() -> None: ...

stubs/reportlab/reportlab/pdfbase/ttfonts.pyi

@@ -1,32 +1,33 @@
-from _typeshed import Incomplete
+from _typeshed import Incomplete, ReadableBuffer, StrOrBytesPath
 from typing import Final, NamedTuple
 from typing_extensions import Self
+from weakref import WeakKeyDictionary
 
 from reportlab.pdfbase import pdfdoc, pdfmetrics
 
 __version__: Final[str]
 
 class TTFError(pdfdoc.PDFError): ...
 
-def SUBSETN(n, table=...): ...
-def makeToUnicodeCMap(fontname, subset): ...
+def SUBSETN(n, table: ReadableBuffer | None = ...) -> bytes: ...
+def makeToUnicodeCMap(fontname: str, subset) -> str: ...
 def splice(stream, offset, value): ...
 
-GF_ARG_1_AND_2_ARE_WORDS: Incomplete
-GF_ARGS_ARE_XY_VALUES: Incomplete
-GF_ROUND_XY_TO_GRID: Incomplete
-GF_WE_HAVE_A_SCALE: Incomplete
-GF_RESERVED: Incomplete
-GF_MORE_COMPONENTS: Incomplete
-GF_WE_HAVE_AN_X_AND_Y_SCALE: Incomplete
-GF_WE_HAVE_A_TWO_BY_TWO: Incomplete
-GF_WE_HAVE_INSTRUCTIONS: Incomplete
-GF_USE_MY_METRICS: Incomplete
-GF_OVERLAP_COMPOUND: Incomplete
-GF_SCALED_COMPONENT_OFFSET: Incomplete
-GF_UNSCALED_COMPONENT_OFFSET: Incomplete
-
-def TTFOpenFile(fn): ...
+GF_ARG_1_AND_2_ARE_WORDS: Final = 1
+GF_ARGS_ARE_XY_VALUES: Final = 2
+GF_ROUND_XY_TO_GRID: Final = 4
+GF_WE_HAVE_A_SCALE: Final = 8
+GF_RESERVED: Final = 16
+GF_MORE_COMPONENTS: Final = 32
+GF_WE_HAVE_AN_X_AND_Y_SCALE: Final = 64
+GF_WE_HAVE_A_TWO_BY_TWO: Final = 128
+GF_WE_HAVE_INSTRUCTIONS: Final = 256
+GF_USE_MY_METRICS: Final = 512
+GF_OVERLAP_COMPOUND: Final = 1024
+GF_SCALED_COMPONENT_OFFSET: Final = 2048
+GF_UNSCALED_COMPONENT_OFFSET: Final = 4096
+
+def TTFOpenFile(fn: StrOrBytesPath) -> tuple[StrOrBytesPath,]: ...
 
 class TTFontParser:
     ttfVersions: Incomplete
@@ -138,18 +139,18 @@ class TTFont:
         subsets: Incomplete
         def __init__(self, asciiReadable: Incomplete | None = None, ttf: Incomplete | None = None) -> None: ...
 
-    fontName: Incomplete
-    face: Incomplete
-    encoding: Incomplete
-    state: Incomplete
+    fontName: str
+    face: TTFontFace
+    encoding: TTEncoding
+    state: WeakKeyDictionary[Incomplete, State]
     def __init__(
         self,
-        name,
+        name: str,
         filename,
         validate: int = 0,
         subfontIndex: int = 0,
-        asciiReadable: Incomplete | None = None,
-        shaped: Incomplete | None = None,
+        asciiReadable: int | None = None,
+        shapable: bool = True,
     ) -> None: ...
     def stringWidth(self, text, size, encoding: str = "utf8"): ...
     def splitString(self, text, doc, encoding: str = "utf-8"): ...
@@ -159,9 +160,9 @@ class TTFont:
     def hbFace(self) -> Incomplete | None: ...
     def hbFont(self, fontSize: float = 10): ...
     @property
-    def isShaped(self) -> bool: ...
-    @isShaped.setter
-    def isShaped(self, v) -> None: ...
+    def shapable(self) -> bool: ...
+    @shapable.setter
+    def shapable(self, v) -> None: ...
     def pdfScale(self, v): ...
     def unregister(self) -> None: ...
 
@@ -179,6 +180,7 @@ class ShapedStr(str):
     def __new__(cls, s, shapeData: ShapeData | None = None) -> Self: ...
     def __radd__(self, other) -> Self: ...
 
+def shapeStr(s: str, fontName: str, fontSize: float): ...
 def freshTTFont(ttfn, ttfpath, **kwds) -> TTFont: ...
 def makeShapedFragWord(w, K: list[Incomplete] = [], V: list[Incomplete] = []) -> type[ShapedFragWord]: ...
 def shapeFragWord(w, features: Incomplete | None = None): ...