pdfpainter 0.1.0__py3-none-any.whl

pdfpainter/__init__.py

@@ -0,0 +1,25 @@
+"""pdfpainter: paint PDF pages to images with Pillow alone, no native PDF engine needed.
+
+Built on pdfsieve (which reads pages with pure-Python pdfminer.six), so it runs anywhere Pillow
+and NumPy run, including PCs where policies block native PDF DLLs.
+
+    >>> import pdfpainter
+    >>> img = pdfpainter.render_pdf("statement.pdf", page=0, dpi=150)
+    >>> img.save("statement-1.png")
+
+The picture is simplified: shapes (with holes), lines, embedded images, and real text set in a
+similar system font. Word and line positions match the PDF exactly, which is what OCR and
+"draw a box over the page" interfaces need.
+"""
+
+from .fonts import FAMILIES, ITALICS, add_font_dir, family_for, find_font, font_dirs, font_for
+from .images import decode_image
+from .painter import MAX_PIXELS, page_size_px, render, render_pdf, to_ppm
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "render", "render_pdf", "page_size_px", "decode_image", "to_ppm",
+    "add_font_dir", "font_dirs", "find_font", "font_for", "family_for", "FAMILIES", "ITALICS", "MAX_PIXELS",
+    "__version__",
+]

pdfpainter/__main__.py

@@ -0,0 +1,99 @@
+"""Command line: ``pdfpainter file.pdf -o page.png`` (or ``python -m pdfpainter ...``)."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from typing import List, Optional
+
+import pdfsieve
+
+from . import __version__, render
+
+
+def parse_pages(spec: Optional[str], count: int) -> List[int]:
+    """'1,3-5' -> [0, 2, 3, 4] (1-based in, 0-based out). None means every page."""
+    if not spec:
+        return list(range(count))
+    out: List[int] = []
+    for part in spec.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if "-" in part:
+            a, b = part.split("-", 1)
+            lo = int(a) if a.strip() else 1
+            hi = int(b) if b.strip() else count
+        else:
+            lo = hi = int(part)
+        for n in range(lo, hi + 1):
+            if not 1 <= n <= count:
+                raise ValueError(f"page {n} out of range (the PDF has {count} pages)")
+            if n - 1 not in out:
+                out.append(n - 1)
+    return out
+
+
+def out_name(pattern: str, page: int, many: bool) -> str:
+    """'{page}' in the name becomes the 1-based page number; with several pages and no
+    '{page}', '-N' goes before the extension."""
+    if "{page}" in pattern:
+        return pattern.replace("{page}", str(page + 1))
+    if many:
+        root, ext = os.path.splitext(pattern)
+        return f"{root}-{page + 1}{ext}"
+    return pattern
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="pdfpainter",
+        description="Paint PDF pages to image files with Pillow alone (simplified rendering, "
+                    "exact positions).")
+    ap.add_argument("pdf", help="the PDF file")
+    ap.add_argument("-o", "--output", default=None,
+                    help="image file to write; the extension picks the format (.png, .jpg, .tif...). "
+                         "'{page}' is replaced by the page number. Default: <pdf name>-{page}.png")
+    ap.add_argument("-p", "--pages", help="pages, 1-based, e.g. 1,3-5 (default: all)")
+    ap.add_argument("-d", "--dpi", type=float, default=150.0, help="resolution (default: 150)")
+    ap.add_argument("--no-text", action="store_true", help="leave real text out (shapes and images only)")
+    ap.add_argument("--password", default="", help="password for an encrypted PDF")
+    ap.add_argument("-V", "--version", action="version", version=f"pdfpainter {__version__}")
+    args = ap.parse_args(argv)
+
+    if args.dpi <= 0:
+        print("pdfpainter: --dpi must be positive", file=sys.stderr)
+        return 2
+    try:
+        doc = pdfsieve.open(args.pdf, password=args.password)
+    except (OSError, pdfsieve.PdfSieveError) as exc:
+        print(f"pdfpainter: {exc}", file=sys.stderr)
+        return 2
+    with doc:
+        try:
+            pages = parse_pages(args.pages, doc.page_count)
+        except ValueError as exc:
+            print(f"pdfpainter: {exc}", file=sys.stderr)
+            return 2
+        pattern = args.output or os.path.splitext(os.path.basename(args.pdf))[0] + "-{page}.png"
+        for i in pages:
+            info: dict = {}
+            img = render(doc.page(i), dpi=args.dpi, info=info, text=not args.no_text)
+            name = out_name(pattern, i, len(pages) > 1)
+            try:
+                img.save(name)
+            except (OSError, ValueError) as exc:
+                print(f"pdfpainter: could not write {name}: {exc}", file=sys.stderr)
+                return 2
+            notes = []
+            if info.get("undecoded"):
+                notes.append(f"{info['undecoded']} image(s) in an unsupported format shown as grey boxes")
+            if info.get("skipped_fills"):
+                notes.append(f"{info['skipped_fills']} pattern/shading fill(s) left out")
+            print(f"{name}  ({img.width} x {img.height})" + (f"  note: {'; '.join(notes)}" if notes else ""))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pdfpainter/fonts.py

@@ -0,0 +1,150 @@
+"""Finding a system font similar to the PDF's font.
+
+pdfpainter never uses the fonts embedded in the PDF. It sets real text in a font from this
+computer that matches the family (sans, serif, mono), weight, slant, and script (Latin, Indic,
+CJK).
+Extra font folders can be added with :func:`add_font_dir` or the ``PDFPAINTER_FONT_DIRS``
+environment variable (folders separated by ``os.pathsep``).
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Dict, List, Optional, Tuple
+
+from PIL import ImageFont
+
+ENV_FONT_DIRS = "PDFPAINTER_FONT_DIRS"
+
+# family -> (regular candidates, bold candidates), first found wins
+FAMILIES: Dict[str, Tuple[List[str], List[str]]] = {
+    "sans": (["arial.ttf", "Arial.ttf", "LiberationSans-Regular.ttf", "segoeui.ttf", "DejaVuSans.ttf",
+              "FreeSans.ttf"],
+             ["arialbd.ttf", "Arial Bold.ttf", "LiberationSans-Bold.ttf", "segoeuib.ttf", "DejaVuSans-Bold.ttf",
+              "FreeSansBold.ttf"]),
+    "serif": (["times.ttf", "Times New Roman.ttf", "LiberationSerif-Regular.ttf", "DejaVuSerif.ttf",
+               "FreeSerif.ttf"],
+              ["timesbd.ttf", "Times New Roman Bold.ttf", "LiberationSerif-Bold.ttf", "DejaVuSerif-Bold.ttf",
+               "FreeSerifBold.ttf"]),
+    "mono": (["cour.ttf", "Courier New.ttf", "LiberationMono-Regular.ttf", "DejaVuSansMono.ttf",
+              "FreeMono.ttf"],
+             ["courbd.ttf", "Courier New Bold.ttf", "LiberationMono-Bold.ttf", "DejaVuSansMono-Bold.ttf",
+              "FreeMonoBold.ttf"]),
+    # scripts the Latin fonts above don't cover
+    "indic": (["Nirmala.ttf", "Nirmala.ttc", "mangal.ttf", "NotoSansDevanagari-Regular.ttf", "Kohinoor.ttc"],
+              ["NirmalaB.ttf", "Nirmala.ttc", "NotoSansDevanagari-Bold.ttf"]),
+    "cjk": (["YuGothR.ttc", "msgothic.ttc", "msyh.ttc", "malgun.ttf", "NotoSansCJK-Regular.ttc",
+             "NotoSansCJKjp-Regular.otf", "PingFang.ttc"],
+            ["YuGothB.ttc", "msyhbd.ttc", "malgunbd.ttf", "NotoSansCJK-Bold.ttc"]),
+}
+
+# family -> (italic candidates, bold italic candidates); scripts without italics fall back upright
+ITALICS: Dict[str, Tuple[List[str], List[str]]] = {
+    "sans": (["ariali.ttf", "Arial Italic.ttf", "LiberationSans-Italic.ttf", "segoeuii.ttf",
+              "DejaVuSans-Oblique.ttf", "FreeSansOblique.ttf"],
+             ["arialbi.ttf", "Arial Bold Italic.ttf", "LiberationSans-BoldItalic.ttf", "segoeuiz.ttf",
+              "DejaVuSans-BoldOblique.ttf", "FreeSansBoldOblique.ttf"]),
+    "serif": (["timesi.ttf", "Times New Roman Italic.ttf", "LiberationSerif-Italic.ttf", "DejaVuSerif-Italic.ttf",
+               "FreeSerifItalic.ttf"],
+              ["timesbi.ttf", "Times New Roman Bold Italic.ttf", "LiberationSerif-BoldItalic.ttf",
+               "DejaVuSerif-BoldItalic.ttf", "FreeSerifBoldItalic.ttf"]),
+    "mono": (["couri.ttf", "Courier New Italic.ttf", "LiberationMono-Italic.ttf", "DejaVuSansMono-Oblique.ttf",
+              "FreeMonoOblique.ttf"],
+             ["courbi.ttf", "Courier New Bold Italic.ttf", "LiberationMono-BoldItalic.ttf",
+              "DejaVuSansMono-BoldOblique.ttf", "FreeMonoBoldOblique.ttf"]),
+}
+
+_extra_dirs: List[str] = []
+_paths: Dict[Tuple[str, bool, bool], Optional[str]] = {}
+_fonts: Dict[Tuple[str, bool, bool, int], object] = {}
+
+
+def add_font_dir(path: str) -> None:
+    """Search this folder for fonts before the system folders."""
+    if path not in _extra_dirs:
+        _extra_dirs.insert(0, path)
+    _paths.clear()
+    _fonts.clear()
+
+
+def font_dirs() -> List[str]:
+    """Folders searched for fonts, in order."""
+    env = [d for d in os.environ.get(ENV_FONT_DIRS, "").split(os.pathsep) if d]
+    if os.name == "nt":
+        system = [os.path.join(os.environ.get("WINDIR", r"C:\Windows"), "Fonts"),
+                  os.path.join(os.environ.get("LOCALAPPDATA", ""), "Microsoft", "Windows", "Fonts")]
+    elif sys.platform == "darwin":
+        system = ["/System/Library/Fonts/Supplemental", "/System/Library/Fonts", "/Library/Fonts",
+                  os.path.expanduser("~/Library/Fonts")]
+    else:
+        system = ["/usr/share/fonts/truetype/liberation", "/usr/share/fonts/truetype/dejavu",
+                  "/usr/share/fonts/truetype/freefont", "/usr/share/fonts/truetype/noto",
+                  "/usr/share/fonts/opentype/noto", "/usr/share/fonts/liberation",
+                  "/usr/share/fonts/dejavu", "/usr/share/fonts", os.path.expanduser("~/.local/share/fonts")]
+    return _extra_dirs + env + system
+
+
+def find_font(family: str, bold: bool, italic: bool = False) -> Optional[str]:
+    """Path of the first installed font for a family and style, or None. A bold or italic
+    request falls back to the plainer styles of the same family."""
+    key = (family, bold, italic)
+    if key not in _paths:
+        found = None
+        regular, bolds = FAMILIES[family]
+        italics, bold_italics = ITALICS.get(family, ([], []))
+        if italic:
+            names = (bold_italics + italics + bolds + regular) if bold else (italics + regular)
+        else:
+            names = (bolds + regular) if bold else regular
+        dirs = font_dirs()
+        for name in names:
+            for d in dirs:
+                p = os.path.join(d, name)
+                if os.path.isfile(p):
+                    found = p
+                    break
+            if found:
+                break
+        _paths[key] = found
+    return _paths[key]
+
+
+def family_for(fontname: str, ch: str) -> str:
+    """Which family to draw a character in: by its script first, then by the PDF font's name."""
+    o = ord(ch[0]) if ch else 0
+    if 0x0900 <= o <= 0x0DFF:
+        return "indic"
+    if o >= 0x2E80 and not 0xFB00 <= o <= 0xFB4F:
+        return "cjk"
+    n = fontname.lower()
+    if any(k in n for k in ("courier", "mono", "consol")):
+        return "mono"
+    if any(k in n for k in ("times", "serif", "roman", "georgia", "cambria", "garamond", "minion")) \
+            and "sans" not in n:
+        return "serif"
+    return "sans"
+
+
+def font_for(fontname: str, ch: str, px: int):
+    """A Pillow font, ``px`` pixels high, to draw ``ch`` in place of the PDF font ``fontname``."""
+    name = fontname.lower()
+    bold = any(k in name for k in ("bold", "black", "heavy", "semibold"))
+    italic = any(k in name for k in ("italic", "oblique", "slant"))
+    fam = family_for(fontname, ch)
+    key = (fam, bold, italic, px)
+    if key not in _fonts:
+        path = find_font(fam, bold, italic) or find_font("sans", bold, italic) or find_font("sans", False)
+        font = None
+        if path:
+            try:
+                font = ImageFont.truetype(path, px)
+            except Exception:
+                font = None
+        if font is None:
+            try:
+                font = ImageFont.load_default(size=px)  # Pillow >= 10.1: scalable built-in font
+            except TypeError:  # older Pillow: fixed tiny bitmap font
+                font = ImageFont.load_default()
+        _fonts[key] = font
+    return _fonts[key]

pdfpainter/images.py

@@ -0,0 +1,128 @@
+"""Decoding images embedded in a PDF into Pillow images, without a PDF engine."""
+
+from __future__ import annotations
+
+import io
+from typing import Optional, Tuple
+
+from PIL import Image, ImageOps
+
+
+def _name(obj) -> str:
+    n = getattr(obj, "name", obj)
+    if isinstance(n, bytes):
+        n = n.decode("latin-1")
+    return str(n)
+
+
+def decode_image(stream) -> Tuple[Optional[Image.Image], bool]:
+    """An embedded image (a pdfminer ``PDFStream``) as ``(picture, is_stencil)``.
+
+    Supported: JPEG (DCT), JPEG 2000 (JPX, if your Pillow reads it), and raw/Flate/LZW/RunLength samples in gray, RGB, CMYK,
+    ICC-based, calibrated and indexed colour spaces at 1, 2, 4, 8 or 16 bits per component, plus
+    1-bit stencil masks. Returns ``(None, False)`` for anything else (JBIG2, DeviceN and other
+    unusual colour spaces).
+
+    For a stencil the picture is the raw 1-bit mask; the caller paints the fill colour where the
+    sample is 0 (or 1 when the image's /Decode array is inverted).
+    """
+    from pdfminer.pdftypes import PDFStream, resolve1
+
+    def get(*keys, default=None):
+        for k in keys:
+            if k in stream:
+                return resolve1(stream[k])
+        return default
+
+    try:
+        filters = [_name(f) for f, _ in stream.get_filters()]
+        last = filters[-1] if filters else ""
+        if last == "JBIG2Decode":
+            return None, False
+        data = stream.get_data()
+        w, h = int(get("Width", "W")), int(get("Height", "H"))
+        stencil = bool(get("ImageMask", "IM", default=False))
+        decode = get("Decode", "D")
+        inverted = bool(decode) and float(decode[0]) > float(decode[1])
+        if last in ("DCTDecode", "DCT", "JPXDecode"):
+            img = Image.open(io.BytesIO(data))
+            img.load()
+            if img.mode == "CMYK":
+                # Adobe JPEGs store CMYK inverted; Pillow already handles the common case
+                img = img.convert("RGB")
+            return img.convert("RGB" if img.mode != "L" else "L"), False
+        bpc = int(get("BitsPerComponent", "BPC", default=1 if stencil else 8))
+        cs = get("ColorSpace", "CS")
+        palette = None
+        if isinstance(cs, list):
+            kind = _name(cs[0])
+            if kind in ("Indexed", "I"):
+                base = resolve1(cs[1])
+                base_n = {"DeviceGray": 1, "G": 1, "DeviceCMYK": 4, "CMYK": 4}.get(
+                    _name(base[0] if isinstance(base, list) else base), 3)
+                if isinstance(base, list) and _name(base[0]) == "ICCBased":
+                    base_n = int(resolve1(base[1]).get("N", 3))
+                look = resolve1(cs[3])
+                look = look.get_data() if isinstance(look, PDFStream) else bytes(look)
+                palette = (base_n, look)
+                ncomp = 1
+            elif kind == "ICCBased":
+                ncomp = int(resolve1(cs[1]).get("N", 3))
+            elif kind in ("CalGray", "Separation"):
+                ncomp = 1
+            elif kind in ("CalRGB", "Lab"):
+                ncomp = 3
+            else:
+                return None, False
+        else:
+            ncomp = {"DeviceGray": 1, "G": 1, "DeviceRGB": 3, "RGB": 3, "DeviceCMYK": 4, "CMYK": 4}.get(
+                _name(cs) if cs is not None else "DeviceGray", 1)
+        if stencil:
+            ncomp, bpc = 1, 1
+
+        if bpc == 1 and ncomp == 1 and palette is None:
+            img = Image.frombytes("1", (w, h), data[: ((w + 7) // 8) * h])
+            if stencil:
+                return img, True
+            img = img.convert("L")
+        else:
+            import numpy as np
+
+            row = (w * ncomp * bpc + 7) // 8
+            arr = np.frombuffer(data[: row * h], dtype=np.uint8).reshape(h, row)
+            if bpc == 8:
+                px = arr[:, : w * ncomp]
+            elif bpc == 16:
+                px = arr[:, : w * ncomp * 2: 2]
+            elif bpc in (1, 2, 4):
+                bits = np.unpackbits(arr, axis=1)[:, : w * ncomp * bpc].reshape(h, w * ncomp, bpc)
+                px = bits.dot(1 << np.arange(bpc - 1, -1, -1)).astype(np.uint8)
+                if palette is None:
+                    px = (px.astype(np.uint16) * 255 // ((1 << bpc) - 1)).astype(np.uint8)
+            else:
+                return None, False
+            px = np.ascontiguousarray(px)
+            if palette is not None:
+                base_n, look = palette
+                table = np.frombuffer(look, dtype=np.uint8)
+                table = table[: (len(table) // base_n) * base_n].reshape(-1, base_n)
+                if base_n == 1:
+                    table = np.repeat(table, 3, axis=1)
+                elif base_n == 4:
+                    k = table[:, 3:4].astype(np.int32)
+                    table = (255 - np.minimum(255, table[:, :3].astype(np.int32) + k)).astype(np.uint8)
+                idx = np.minimum(px, len(table) - 1)
+                img = Image.fromarray(np.ascontiguousarray(table[idx]))
+            elif ncomp == 1:
+                img = Image.fromarray(px.reshape(h, w))
+            elif ncomp == 3:
+                img = Image.fromarray(px.reshape(h, w, 3))
+            elif ncomp == 4:
+                img = Image.frombytes("CMYK", (w, h), px.tobytes()).convert("RGB")
+            else:
+                return None, False
+        if inverted and not stencil:
+            img = ImageOps.invert(img.convert("L") if img.mode == "1" else img)
+        return img, False
+    except Exception:
+        return None, False

pdfpainter/painter.py

@@ -0,0 +1,251 @@
+"""Painting a pdfsieve page with Pillow."""
+
+from __future__ import annotations
+
+import math
+from typing import Optional, Tuple
+
+from PIL import Image, ImageChops, ImageDraw, ImageOps
+
+from pdfsieve import Page, Picture, Shape
+
+from .fonts import font_for
+from .images import decode_image
+
+MAX_PIXELS = 60_000_000
+"""Pages with vector content are painted at twice the size and shrunk for smooth edges, unless
+the doubled canvas would exceed this many pixels."""
+
+R = Image.Resampling
+T = Image.Transpose
+
+
+# ---------------------------------------------------------------- shapes
+
+def _flatten(pts, s: float) -> list:
+    """A subpath as a polygon in pixels; curves become short straight pieces."""
+    out = [(pts[0][1] * s, pts[0][2] * s)]
+    for p in pts[1:]:
+        if p[0] == "l":
+            out.append((p[1] * s, p[2] * s))
+        else:
+            x0, y0 = out[-1]
+            x1, y1, x2, y2, x3, y3 = (v * s for v in p[1:])
+            span = abs(x1 - x0) + abs(y1 - y0) + abs(x2 - x1) + abs(y2 - y1) + abs(x3 - x2) + abs(y3 - y2)
+            n = min(max(int(span / 3) + 1, 3), 32)
+            for k in range(1, n + 1):
+                t = k / n
+                u = 1 - t
+                a, b, c, d = u * u * u, 3 * u * u * t, 3 * u * t * t, t * t * t
+                out.append((a * x0 + b * x1 + c * x2 + d * x3, a * y0 + b * y1 + c * y2 + d * y3))
+    return out
+
+
+def _area(poly) -> float:
+    a = 0.0
+    for (x0, y0), (x1, y1) in zip(poly, poly[1:] + poly[:1]):
+        a += x0 * y1 - x1 * y0
+    return a / 2
+
+
+def _fill(canvas: Image.Image, draw: ImageDraw.ImageDraw, polys, color, evenodd: bool) -> None:
+    polys = [p for p in polys if len(p) >= 3]
+    if not polys:
+        return
+    if len(polys) == 1:
+        draw.polygon(polys[0], fill=color)
+        return
+    import numpy as np
+
+    W, H = canvas.size
+    x0 = max(int(math.floor(min(x for p in polys for x, _ in p))), 0)
+    y0 = max(int(math.floor(min(y for p in polys for _, y in p))), 0)
+    x1 = min(int(math.ceil(max(x for p in polys for x, _ in p))) + 1, W)
+    y1 = min(int(math.ceil(max(y for p in polys for _, y in p))) + 1, H)
+    if x1 <= x0 or y1 <= y0:
+        return
+    mask = np.zeros((y1 - y0, x1 - x0), dtype=bool)
+    areas = [_area(p) for p in polys]
+    order = sorted(range(len(polys)), key=lambda i: -abs(areas[i]))
+    outer_sign = areas[order[0]] >= 0
+    for i in order:
+        p = polys[i]
+        px0 = min(max(int(math.floor(min(x for x, _ in p))), x0), x1 - 1)
+        py0 = min(max(int(math.floor(min(y for _, y in p))), y0), y1 - 1)
+        px1 = max(min(int(math.ceil(max(x for x, _ in p))) + 1, x1), px0 + 1)
+        py1 = max(min(int(math.ceil(max(y for _, y in p))) + 1, y1), py0 + 1)
+        small = Image.new("1", (px1 - px0, py1 - py0), 0)
+        ImageDraw.Draw(small).polygon([(x - px0, y - py0) for x, y in p], fill=1)
+        sub = np.asarray(small, dtype=bool)
+        view = mask[py0 - y0:py1 - y0, px0 - x0:px1 - x0]
+        if evenodd:
+            view ^= sub
+        else:
+            # Non-zero rule, approximated: biggest outlines first; an outline wound the other
+            # way that lies inside ink is a hole (the inside of "o"), anything else is ink.
+            inside = sub.any() and view[sub].mean() > 0.5
+            if inside and (areas[i] >= 0) != outer_sign:
+                view &= ~sub
+            else:
+                view |= sub
+    canvas.paste(color, (x0, y0), Image.fromarray(mask.astype("uint8") * 255))
+
+
+# ---------------------------------------------------------------- images
+
+def _place(canvas: Image.Image, draw, pic: Picture, s: float) -> bool:
+    """Paint one embedded image where its matrix puts it. False if it couldn't be decoded."""
+    a, b, c, d, e, f = pic.matrix
+    corners = [(e, f), (e + a, f + b), (e + c, f + d), (e + a + c, f + b + d)]
+    bx0 = int(math.floor(min(x for x, _ in corners) * s))
+    by0 = int(math.floor(min(y for _, y in corners) * s))
+    bx1 = int(math.ceil(max(x for x, _ in corners) * s))
+    by1 = int(math.ceil(max(y for _, y in corners) * s))
+    bw, bh = bx1 - bx0, by1 - by0
+    if bw < 1 or bh < 1 or bw * bh > 4 * canvas.size[0] * canvas.size[1]:
+        return True
+    img, stencil = decode_image(pic.stream)
+    if img is None:
+        draw.rectangle((bx0, by0, bx1, by1), fill=(236, 236, 236), outline=(170, 170, 170))
+        return False
+    if stencil:
+        from pdfminer.pdftypes import resolve1
+
+        dec = resolve1(pic.stream.get("Decode") or pic.stream.get("D"))
+        paint_ones = bool(dec) and float(dec[0]) > float(dec[1])
+        ink = img.convert("L")
+        mask_src = ink if paint_ones else ImageOps.invert(ink)
+        img = None
+    else:
+        mask_src = None
+    src = img if img is not None else mask_src
+    w, h = src.size
+    if abs(b) < 1e-6 and abs(c) < 1e-6:  # upright: the usual case
+        if a < 0:
+            src = src.transpose(T.FLIP_LEFT_RIGHT)
+        if d > 0:  # image's top row lands at the bottom
+            src = src.transpose(T.FLIP_TOP_BOTTOM)
+        small = bw < w or bh < h
+        src = src.resize((bw, bh), R.LANCZOS if small else R.BICUBIC)
+        valid = None
+    else:  # rotated or skewed
+        # image pixel (i, j) -> canvas: u = i / w, v = 1 - j / h
+        m00, m01, m02 = s * a / w, -s * c / h, s * (c + e) - bx0
+        m10, m11, m12 = s * b / w, -s * d / h, s * (d + f) - by0
+        det = m00 * m11 - m01 * m10
+        if abs(det) < 1e-12:
+            return True
+        i00, i01, i10, i11 = m11 / det, -m01 / det, -m10 / det, m00 / det
+        coeffs = (i00, i01, -(i00 * m02 + i01 * m12), i10, i11, -(i10 * m02 + i11 * m12))
+        valid = Image.new("L", (w, h), 255).transform((bw, bh), Image.Transform.AFFINE, coeffs, R.NEAREST)
+        src = src.transform((bw, bh), Image.Transform.AFFINE, coeffs, R.BICUBIC)
+    if mask_src is not None:  # stencil: paint the fill colour through the mask
+        if valid is not None:
+            src = ImageChops.multiply(src, valid)
+        canvas.paste(pic.color or (0, 0, 0), (bx0, by0), src)
+    else:
+        canvas.paste(src.convert("RGB"), (bx0, by0), valid)
+    return True
+
+
+# ---------------------------------------------------------------- page
+
+def page_size_px(page: Page, zoom: float) -> Tuple[int, int]:
+    """The size in pixels :func:`render` produces: the same rounding PDFium uses, so the two are
+    interchangeable."""
+    return (max(math.ceil(page.width * zoom - 1e-6), 1), max(math.ceil(page.height * zoom - 1e-6), 1))
+
+
+def render(page: Page, zoom: float = 1.0, info: Optional[dict] = None, *, dpi: Optional[float] = None,
+           background: Tuple[int, int, int] = (255, 255, 255), text: bool = True,
+           antialias: bool = True) -> Image.Image:
+    """Paint a page as an RGB Pillow image.
+
+    zoom:       pixels per point (1.0 = 72 dpi). ``dpi`` sets the same thing in dots per inch.
+    info:       a dict that receives ``undecoded`` (images that could not be shown) and
+                ``skipped_fills`` (shapes filled with a pattern or shading, left out).
+    background: page colour.
+    text:       False leaves real text out (shapes and images only), e.g. to see what a page
+                looks like to OCR once its text layer is ignored.
+    antialias:  paint vector pages at twice the size and shrink, for smooth edges.
+    """
+    if dpi is not None:
+        zoom = dpi / 72.0
+    if zoom <= 0:
+        raise ValueError("zoom must be positive")
+    W, H = page_size_px(page, zoom)
+    has_vector = bool(page.glyphs) or any(isinstance(i, Shape) for i in page.items)
+    ss = 2 if antialias and has_vector and W * H * 4 <= MAX_PIXELS else 1
+    s = zoom * ss
+    canvas = Image.new("RGB", (W * ss, H * ss), background)
+    draw = ImageDraw.Draw(canvas)
+    undecoded = skipped = 0
+    for it in page.items:
+        if isinstance(it, Picture):
+            if not _place(canvas, draw, it, s):
+                undecoded += 1
+            continue
+        polys = [(_flatten(pts, s), closed) for pts, closed in it.subpaths]
+        if it.fill is not None:
+            _fill(canvas, draw, [p for p, _ in polys], it.fill, it.evenodd)
+        elif it.stroke is None:
+            skipped += 1
+        if it.stroke is not None:
+            width = max(int(round(it.width * s)), ss)
+            for p, closed in polys:
+                if closed:
+                    p = p + p[:1]
+                if len(p) >= 2:
+                    draw.line(p, fill=it.stroke, width=width, joint="curve" if width > 2 else None)
+    if text:
+        for g in page.glyphs:
+            if not g.visible or not g.text.strip() or g.text == "�":
+                continue
+            px = max(int(round(g.size * s)), 4)
+            font = font_for(g.font, g.text, px)
+            if not g.upright:
+                _sideways(canvas, g, font, px, s)
+                continue
+            try:
+                draw.text((g.x0 * s, g.base * s), g.text, font=font, fill=g.color or (0, 0, 0), anchor="ls")
+            except Exception:  # bitmap fallback font has no anchors
+                draw.text((g.x0 * s, g.y0 * s), g.text, font=font, fill=g.color or (0, 0, 0))
+    if info is not None:
+        info["undecoded"] = undecoded
+        info["skipped_fills"] = skipped
+    return canvas.resize((W, H), R.LANCZOS) if ss > 1 else canvas
+
+
+def _sideways(canvas: Image.Image, g, font, px: int, s: float) -> None:
+    """A character that is turned on the page: set it upright on a scrap, turn the scrap, and
+    stamp it so its baseline corner sits where the PDF put it."""
+    try:
+        pad = px
+        scrap = Image.new("L", (px * 2 + 2 * pad, px * 2 + 2 * pad), 0)
+        ImageDraw.Draw(scrap).text((scrap.width // 2, scrap.height // 2), g.text, font=font, fill=255,
+                                   anchor="ls")
+        scrap = scrap.rotate(g.turn)  # turns about the centre, where the baseline starts
+        # the baseline start in the box: the corner the writing leaves from
+        ox, oy = {90: (g.x1, g.y1), 180: (g.x1, g.y0), 270: (g.x0, g.y0)}.get(g.turn, (g.x0, g.y1))
+        d = 0.22 * g.size  # the box includes the descender; lift the baseline off the box edge
+        ox, oy = {90: (ox - d, oy), 180: (ox, oy + d), 270: (ox + d, oy)}.get(g.turn, (ox, oy - d))
+        canvas.paste(g.color or (0, 0, 0),
+                     (int(round(ox * s - scrap.width / 2)), int(round(oy * s - scrap.height / 2))), scrap)
+    except Exception:
+        pass
+
+
+def render_pdf(source, page: int = 0, zoom: float = 1.0, *, dpi: Optional[float] = None, password: str = "",
+               info: Optional[dict] = None, **kwargs) -> Image.Image:
+    """Open a PDF (path, bytes or binary file) and paint one page (0-based). Other keyword
+    arguments go to :func:`render`."""
+    import pdfsieve
+
+    with pdfsieve.open(source, password=password) as doc:
+        return render(doc.page(page), zoom, info, dpi=dpi, **kwargs)
+
+
+def to_ppm(img: Image.Image) -> bytes:
+    """PPM bytes, which Tk's ``PhotoImage`` reads without any extra library."""
+    img = img.convert("RGB")
+    return b"P6 %d %d 255\n" % img.size + img.tobytes()

pdfpainter-0.1.0.dist-info/METADATA

@@ -0,0 +1,312 @@
+Metadata-Version: 2.4
+Name: pdfpainter
+Version: 0.1.0
+Summary: Paint PDF pages to images with Pillow alone: no native PDF engine, permissive licence, exact text positions. For OCR and page previews where PDF DLLs can't run.
+Author: Vaibhav Rawat (AdRaw App Studio)
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Vibhu1712/pdfpainter
+Project-URL: Issues, https://github.com/Vibhu1712/pdfpainter/issues
+Project-URL: Changelog, https://github.com/Vibhu1712/pdfpainter/blob/main/CHANGELOG.md
+Keywords: pdf,render,rasterize,pdf to image,pillow,ocr,pure python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
+Classifier: Topic :: Office/Business
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+License-File: THIRD_PARTY_NOTICES.md
+Requires-Dist: pdfsieve>=0.1.0
+Requires-Dist: pdfminer.six>=20240706
+Requires-Dist: Pillow>=9.1
+Requires-Dist: numpy>=1.21
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: reportlab>=4; python_version >= "3.10" and extra == "test"
+Requires-Dist: reportlab<=4.5.0,>=4; python_version < "3.10" and extra == "test"
+Dynamic: license-file
+
+# pdfpainter
+
+**Paint PDF pages to images with Pillow alone: no native PDF engine, Apache-2.0 licensed, text in exactly the right place.**
+
+```python
+import pdfpainter
+
+img = pdfpainter.render_pdf("payslip.pdf", page=0, dpi=150)   # a Pillow image
+img.save("payslip-1.png")
+```
+
+![The same payslip painted by PDFium and by pdfpainter](docs/comparison.png)
+
+## Why pdfpainter
+
+Most ways to turn a PDF page into an image load a native engine: MuPDF, PDFium, Poppler or Ghostscript. That fails where policies block unsigned DLLs (Windows Application Control on government and bank PCs, locked-down servers), and some of those engines are AGPL or GPL.
+
+pdfpainter paints pages with **Pillow and NumPy only**, from what [pdfsieve](https://github.com/Vibhu1712/pdfsieve) reads with pure-Python pdfminer.six. It is built for two jobs:
+
+1. **OCR** of pages with no usable text layer: scans, and text drawn as outlines (for example PDFs from "Microsoft Print to PDF"). Letter outlines are filled with their holes, so OCR  reads them.
+2. **Showing a page on screen** so users can see it, click on it, or drag boxes over it. Words land in exactly the positions the PDF gives them.
+
+It is **not** a full PDF renderer; see [what is drawn](#what-is-drawn-and-what-isnt). For pixel-perfect output, use PDFium (pypdfium2) when it's available and fall back to pdfpainter when it isn't. The two produce images of the same size, so they're interchangeable.
+
+## Contents
+
+- [Install](#install)
+- [Quick start](#quick-start)
+- [Command line](#command-line)
+- [API reference](#api-reference)
+- [Recipes](#recipes)
+- [What is drawn, and what isn't](#what-is-drawn-and-what-isnt)
+- [Fonts](#fonts)
+- [Speed](#speed)
+- [Development](#development)
+- [Licence](#licence)
+
+## Install
+
+```bash
+pip install pdfpainter
+```
+
+Python 3.9 or newer. Installs pdfsieve, pdfminer.six, Pillow and NumPy, all with permissive licences and wheels for every common platform.
+
+## Quick start
+
+```python
+import pdfpainter
+import pdfsieve
+
+# one call: open, paint, close
+img = pdfpainter.render_pdf("statement.pdf", page=0, dpi=200)
+
+# or paint pages you already opened with pdfsieve
+with pdfsieve.open("statement.pdf") as doc:
+    for page in doc:
+        img = pdfpainter.render(page, zoom=2.0)          # 2 pixels per point = 144 dpi
+        img.save(f"statement-{page.index + 1}.png")
+
+# find out what couldn't be drawn
+info = {}
+img = pdfpainter.render_pdf("scan.pdf", dpi=300, info=info)
+print(info)   # {'undecoded': 0, 'skipped_fills': 0}
+```
+
+**Zoom and dpi.** `zoom` is pixels per PDF point; `dpi = zoom × 72`. A word box from pdfsieve maps onto the image by multiplying each coordinate by `zoom`.
+
+## Command line
+
+```bash
+pdfpainter payslip.pdf                         # every page to payslip-1.png, payslip-2.png, ...
+pdfpainter payslip.pdf -o page.png -p 1        # one page
+pdfpainter payslip.pdf -o "out/p{page}.jpg"    # {page} is the page number; extension picks the format
+pdfpainter payslip.pdf --dpi 300               # default 150
+pdfpainter payslip.pdf --no-text               # shapes and images only
+pdfpainter locked.pdf --password secret
+```
+
+Each file written is listed with its size, plus a note if something on the page couldn't be shown:
+
+```
+k-1.png  (417 x 417)  note: 1 image(s) in an unsupported format shown as grey boxes
+```
+
+## API reference
+
+### `render(page, zoom=1.0, info=None, *, dpi=None, background=(255, 255, 255), text=True, antialias=True)`
+
+Paint a `pdfsieve.Page` and return an RGB `PIL.Image.Image`.
+
+| Argument | Meaning |
+|---|---|
+| `page` | A page from `pdfsieve.open(...).page(i)`. |
+| `zoom` | Pixels per point. `1.0` is 72 dpi. |
+| `dpi` | Alternative to `zoom`: dots per inch. |
+| `info` | A dict to receive `undecoded` (images in an unsupported format, drawn as grey boxes)  and `skipped_fills` (shapes filled with a pattern or shading, left out). |
+| `background` | Page colour. |
+| `text` | `False` leaves the text layer out, to see what a page looks like without it. |
+| `antialias` | Paint vector content at twice the size, then shrink, for smooth edges. Turn off for speed. |
+
+The image size is `ceil(width × zoom) × ceil(height × zoom)`, the same rounding PDFium uses
+(see `page_size_px(page, zoom)`).
+
+### `render_pdf(source, page=0, zoom=1.0, *, dpi=None, password="", info=None, **kwargs)`
+
+Open a PDF (path, bytes or binary file object), paint one page (0-based), and close it. Other
+keyword arguments go to `render`.
+
+### `decode_image(stream) -> (image or None, is_stencil)`
+
+Decode one embedded image (a pdfminer stream, e.g. `page.pictures[0].stream`) into a Pillow image,
+for extracting a scan's image without rendering the whole page. Returns `(None, False)` for
+unsupported formats.
+
+### Fonts
+
+| | |
+|---|---|
+| `add_font_dir(path)` | Search a folder for fonts before the system folders. |
+| `font_dirs()` | The folders searched, in order. |
+| `find_font(family, bold, italic=False)` | Path of the font used for `"sans"`, `"serif"`, `"mono"`, `"indic"` or `"cjk"`. |
+| `font_for(pdf_font_name, char, px)` | The Pillow font used to draw a character. |
+| `FAMILIES`, `ITALICS` | The candidate font file names per family; edit to prefer other fonts. |
+
+The `PDFPAINTER_FONT_DIRS` environment variable adds folders too (separated by `;` on Windows and
+`:` elsewhere).
+
+### Other
+
+| | |
+|---|---|
+| `page_size_px(page, zoom)` | Size in pixels `render` will produce. |
+| `to_ppm(img)` | PPM bytes that Tkinter's `PhotoImage(data=...)` shows with no extra libraries. |
+| `MAX_PIXELS` | Above this canvas size, `antialias` is skipped to save memory. |
+
+## Recipes
+
+Runnable versions live in [`examples/`](examples). Make the sample PDF with
+`python examples/make_sample_pdf.py` (needs `pip install reportlab`).
+
+### OCR a page that has no text layer
+
+```python
+import numpy as np
+import pdfpainter, pdfsieve
+from rapidocr import RapidOCR        # pip install rapidocr onnxruntime
+
+zoom = 300 / 72
+with pdfsieve.open("printed-to-pdf.pdf") as doc:
+    img = pdfpainter.render(doc.page(0), zoom)
+
+result = RapidOCR()(np.asarray(img))
+for quad, text in zip(result.boxes, result.txts):
+    xs, ys = [p[0] for p in quad], [p[1] for p in quad]
+    print(min(xs) / zoom, min(ys) / zoom, text)    # back in PDF points, like pdfsieve's words
+```
+
+[`examples/ocr_page.py`](examples/ocr_page.py) does the same with RapidOCR or, if that isn't
+installed, Tesseract.
+
+### Draw word boxes over the page
+
+```python
+from PIL import ImageDraw
+
+zoom = 2.0
+with pdfsieve.open("sample.pdf") as doc:
+    page = doc.page(0)
+    img = pdfpainter.render(page, zoom)
+    draw = ImageDraw.Draw(img)
+    for w in page.words():
+        draw.rectangle([v * zoom for v in w[:4]], outline="red", width=2)
+img.save("boxes.png")
+```
+
+### PDFium when allowed, pdfpainter when not
+
+```python
+def page_image(path, index, zoom):
+    try:
+        import pypdfium2 as pdfium
+        pdf = pdfium.PdfDocument(path)
+        try:
+            return pdf[index].render(scale=zoom).to_pil().convert("RGB")
+        finally:
+            pdf.close()
+    except Exception:                 # not installed, or its DLL is blocked
+        return pdfpainter.render_pdf(path, index, zoom)
+```
+
+### Show a page in Tkinter with no extra libraries
+
+```python
+import tkinter as tk
+
+root = tk.Tk()
+photo = tk.PhotoImage(data=pdfpainter.to_ppm(pdfpainter.render_pdf("sample.pdf", dpi=96)))
+tk.Label(root, image=photo).pack()
+root.mainloop()
+```
+
+### Pull the scanned image out of a page
+
+```python
+with pdfsieve.open("scan.pdf") as doc:
+    pic = doc.page(0).pictures[0]
+    img, is_stencil = pdfpainter.decode_image(pic.stream)
+    if img is not None:
+        img.save("scan.png")          # at the scan's own resolution
+```
+
+## What is drawn, and what isn't
+
+**Drawn**
+
+- Filled and stroked paths, with curves, line widths and colours (gray, RGB, CMYK, spot tints).
+- Holes in shapes under both fill rules, so letters drawn as outlines (`o`, `e`, `8`) keep their
+  counters and OCR reads them.
+- Embedded images, upright or rotated: JPEG, JPEG 2000 (if your Pillow reads it), and raw, Flate,
+  LZW or RunLength data in gray, RGB, CMYK, ICC, calibrated and indexed colour spaces at
+  1–16 bits; 1-bit stencil masks in the current fill colour.
+- Real text in a similar system font (sans, serif or mono, bold and italic, Indic and CJK
+  scripts), on its exact baseline, including sideways and upside-down text. Invisible text, such
+  as a scan's OCR layer, is not drawn.
+
+**Not drawn**
+
+- Clipping paths: content outside a clip still shows.
+- Transparency and blend modes: everything is opaque.
+- Pattern and shading fills (gradients): left out and counted in `info["skipped_fills"]`.
+- Dashed lines are drawn solid; line caps and joins are approximated.
+- The PDF's own embedded fonts: text is set in a system font, so letter shapes and widths differ
+  slightly, though each character starts where the PDF puts it.
+- JBIG2 images (common in scanned archives) and unusual colour spaces (DeviceN, Lab images): drawn
+  as grey boxes and counted in `info["undecoded"]`.
+- Annotations and form-field appearances.
+
+## Fonts
+
+Text is set in fonts already on the computer:
+
+| Family | Windows | macOS | Linux |
+|---|---|---|---|
+| sans | Arial, Segoe UI | Arial | Liberation Sans, DejaVu Sans, FreeSans |
+| serif | Times New Roman | Times New Roman | Liberation Serif, DejaVu Serif, FreeSerif |
+| mono | Courier New | Courier New | Liberation Mono, DejaVu Sans Mono, FreeMono |
+| indic | Nirmala UI, Mangal | Kohinoor | Noto Sans Devanagari |
+| cjk | Yu Gothic, MS Gothic, Microsoft YaHei, Malgun Gothic | PingFang | Noto Sans CJK |
+
+The family is chosen from the PDF's font name (`Times`, `Courier`, `Bold`, `Italic`, ...) and the
+character's script. With no matching font installed, Pillow's built-in font is used. On a minimal
+Linux server, `apt install fonts-liberation` gives good results.
+
+## Speed
+
+In testing, painting at 150 dpi took about **100–200 ms per page**, on top of pdfsieve's reading
+time; text-heavy pages take longest. Turning off `antialias` cut that to **20–130 ms**, at the
+cost of rougher edges. For OCR, antialiasing usually helps accuracy, so keep it on there.
+
+## Development
+
+```bash
+git clone https://github.com/Vibhu1712/pdfpainter
+cd pdfpainter
+pip install -e ".[test]"
+pytest
+```
+
+The tests build their sample PDFs at run time (with reportlab, plus a few hand-written PDFs for
+image formats), and compare page sizes against PDFium when pypdfium2 is installed.
+
+## Licence
+
+Apache License 2.0; see [LICENSE](LICENSE). Copyright 2026 Vaibhav Rawat (AdRaw App Studio).
+Dependencies and their licences are listed in [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).
+
+pdfpainter began as the fallback page painter inside **docextract by AdRaw App Studio**, an
+offline PDF-to-Excel extraction tool, and is published so others can use it too.

pdfpainter-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pdfpainter/__init__.py,sha256=jvHdey6Adz6n0dG0S3-3AFEQAQ1yeWBMNjXrA_jKpTg,1059
+pdfpainter/__main__.py,sha256=Epg3MbfrZvD3cgGCR3nhD3EF7zbN3et9EZ69SeVq_iY,3943
+pdfpainter/fonts.py,sha256=a36Ef3xsiliekMtBIqMQCIW350rFhxKY0qYBGQPlCx0,6972
+pdfpainter/images.py,sha256=RYQAkYAgnm-7bQn0FaddZgSP2qz03V31869Dyrnut_s,5456
+pdfpainter/painter.py,sha256=na2-yjaBNXg5S5-Efu_zyrUVCLPtWupXQwWhTeym_cA,11066
+pdfpainter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pdfpainter-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+pdfpainter-0.1.0.dist-info/licenses/NOTICE,sha256=SS0HjcOaaG9uEXCAR8-p1UyKiRo7jAmpHMz8rays24Q,252
+pdfpainter-0.1.0.dist-info/licenses/THIRD_PARTY_NOTICES.md,sha256=XJ3HKdRw_XotpECb_f8QP0hvsv7ifxtAh3BJWlNz4wI,2025
+pdfpainter-0.1.0.dist-info/METADATA,sha256=4IEMCej38rtcVuuWQUP39ehbM8Ny7Gnr8Q-t3MFasQE,12603
+pdfpainter-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+pdfpainter-0.1.0.dist-info/entry_points.txt,sha256=m0XlZ7DP9rCYvoxg2MJ4QLJ67BAzmDjz1wihNJccLLM,56
+pdfpainter-0.1.0.dist-info/top_level.txt,sha256=anPvpmaj4S0cDRbT1EXSc9UiOApOukhht437LbrtmBw,11
+pdfpainter-0.1.0.dist-info/RECORD,,

pdfpainter-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pdfpainter-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pdfpainter = pdfpainter.__main__:main

pdfpainter-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pdfpainter-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,7 @@
+pdfpainter
+Copyright 2026 Vaibhav Rawat (AdRaw App Studio)
+
+This product is licensed under the Apache License, Version 2.0 (see LICENSE).
+It paints PDF pages to images with Pillow alone.
+
+Originally developed as part of docextract by AdRaw App Studio.

pdfpainter-0.1.0.dist-info/licenses/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,53 @@
+# Third-party notices
+
+pdfpainter does not copy code from these projects; it depends on them at run time.
+They are installed separately by pip, under their own licences, listed here for convenience.
+
+## pdfsieve
+
+Apache License 2.0. Copyright 2026 Vaibhav Rawat (AdRaw App Studio).
+https://github.com/YOUR-GITHUB-USER/pdfsieve
+
+## pdfminer.six
+
+MIT License. https://github.com/pdfminer/pdfminer.six
+
+```
+Copyright (c) 2004-2016  Yusuke Shinyama <yusuke at shinyama dot jp>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
+
+## Pillow
+
+MIT-CMU License (HPND). Copyright 1997-2011 Secret Labs AB, 1995-2011 Fredrik Lundh and
+contributors, 2010 Jeffrey 'Alex' Clark and contributors. https://github.com/python-pillow/Pillow
+
+## NumPy
+
+BSD 3-Clause License. Copyright 2005 NumPy Developers. https://github.com/numpy/numpy
+
+## Test-only dependencies
+
+pytest (MIT) and reportlab (BSD) are used to run the test suite and are not needed to use
+pdfpainter. pypdfium2 (Apache-2.0 / BSD-3-Clause) is used, when installed, to compare
+page sizes in the tests.

pdfpainter-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pdfpainter