vec-io 0.1.0__py3-none-any.whl

vec_io/__init__.py

@@ -0,0 +1,38 @@
+"""vec_io: create PDF files and images in Python, with no dependencies (a bundled C library
+does the heavy lifting).
+
+Basic usage::
+
+    import vec_io
+
+    doc = vec_io.Document(unit="mm")
+    page = doc.add_page(size="A4")
+    page.fill_rect(20, 20, 50, 30, fill="tomato")
+    page.fill_text("Hello", 20, 70)
+    doc.save("hello.pdf")
+    page.render(dpi=150).save("hello.png")
+
+    vec_io.convert("drawing.svg", "drawing.pdf")
+"""
+
+from .canvas import Canvas
+from .document import Bookmark, Document, Page
+from .fonts.fontdb import FontDB
+from .geometry import Matrix, Path
+from .image import AVIF, JPEG, JXL, PNG, Image, ImagePolicy
+from .filter import Filter
+from .paint import (CMYK, Color, LinearGradient, Marker, Mask, Paint, PathMarker, Pattern,
+                    RadialGradient, Spot, rgb255)
+from .svg import SVGDocument, SVGParseError, convert
+from .text import Content, Font, GlyphRun, Span
+from .text.breaking import TextLayout
+
+__all__ = ["convert", "SVGDocument", "SVGParseError",
+           "Document", "Page", "Canvas", "Bookmark",
+           "Color", "CMYK", "Spot", "rgb255", "Paint", "LinearGradient", "RadialGradient",
+           "Pattern", "Mask", "Marker", "PathMarker", "Filter",
+           "Matrix", "Path", "Font", "GlyphRun", "Span", "Content", "TextLayout", "FontDB",
+           "Image", "ImagePolicy", "PNG", "JPEG", "JXL", "AVIF",
+           "__version__"]
+
+__version__ = "0.1.0"

vec_io/__main__.py

@@ -0,0 +1,138 @@
+"""Command line interface: ``python -m vec_io input.svg [output.pdf]``."""
+
+import argparse
+import os
+import sys
+
+from . import AVIF, JPEG, JXL, PNG, ImagePolicy, SVGParseError, __version__, convert
+from .raster import RasterizationError
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="vec_io", description="Convert an SVG file to PDF (or PNG, JPEG, JPEG XL, AVIF).")
+    parser.add_argument("input", help="input SVG file, or '-' for stdin")
+    parser.add_argument("output", nargs="?",
+                        help="output file ('-' for stdout); defaults to the "
+                             "input name with the extension of --format")
+    parser.add_argument("--format", choices=["pdf", "png", "jpeg", "jxl", "avif"], default="pdf",
+                        help="output format (default pdf)")
+    parser.add_argument("--no-compress", action="store_true",
+                        help="write uncompressed content streams")
+    parser.add_argument("--compression", choices=["fast", "balanced", "best"],
+                        default=None,
+                        help="zlib level 1, zlib level 6 (default), or vec_io's near-optimal "
+                             "Deflate; for PNG output, balanced and best also search the "
+                             "smallest pixel layout; for JPEG output, fast skips trellis "
+                             "quantization, best tries several progressive scan orders; for "
+                             "JPEG XL and AVIF, the encoder's effort")
+    parser.add_argument("--font-dir", action="append", default=[], metavar="DIR",
+                        help="extra directory to search for fonts (repeatable)")
+    parser.add_argument("--no-system-fonts", action="store_true",
+                        help="do not use fonts installed on the system")
+    parser.add_argument("--filters", action="store_true",
+                        help="apply SVG filter effects (rasterized)")
+    parser.add_argument("--quality", type=int, default=None, metavar="N",
+                        help="store rasterized content as JPEG (JPEG XL with --jxl) of "
+                             "quality N (1-100); with --format jpeg, jxl or avif, the "
+                             "quality of the image; with --format png, a lossy palette")
+    parser.add_argument("--jxl", action="store_true",
+                        help="write the PDF's images as JPEG XL (/JXLDecode, read by PDFium; "
+                             "needs libjxl)")
+    parser.add_argument("--pdf-a", choices=["2b", "2u", "3b"], default=None,
+                        help="write a PDF/A file of this conformance level")
+    parser.add_argument("--simplify", nargs="?", const="true", default=None, metavar="DPI",
+                        help="leave out what later content hides at DPI (default 600); "
+                             "'auto': only where it pays off")
+    parser.add_argument("--dpi", type=float, default=96,
+                        help="resolution of image output (default 96: 1px per CSS px)")
+    parser.add_argument("--version", action="version", version="%(prog)s " + __version__)
+    args = parser.parse_args(argv)
+    if not args.dpi > 0:
+        parser.error("--dpi must be positive")
+    simplify = None
+    if args.simplify is not None:
+        if args.simplify.lower() == "auto":
+            simplify = "auto"
+        else:
+            try:
+                simplify = True if args.simplify == "true" else float(args.simplify)
+            except ValueError:
+                parser.error("--simplify takes a resolution in dpi or 'auto'")
+            if simplify is not True and not 0 < simplify < float("inf"):
+                parser.error("--simplify must be positive")
+    fmt = args.format
+    if fmt != "pdf":
+        pdf_only = [flag for flag, used in (("--pdf-a", args.pdf_a is not None),
+                                            ("--jxl", args.jxl),
+                                            ("--no-compress", args.no_compress))
+                    if used]
+        if pdf_only:
+            parser.error(f"{', '.join(pdf_only)} cannot be used with --format {fmt}")
+    if args.quality is not None and not 1 <= args.quality <= 100:
+        parser.error("--quality must be between 1 and 100")
+
+    try:
+        if args.input == "-":
+            data = sys.stdin.buffer.read()
+            base_dir = os.getcwd()
+        else:
+            with open(args.input, "rb") as fh:
+                data = fh.read()
+            base_dir = os.path.dirname(os.path.abspath(args.input))
+    except OSError as exc:
+        parser.exit(1, f"vec_io: cannot read input: {exc}\n")
+
+    options = dict(base_dir=base_dir, font_dirs=args.font_dir,
+                   system_fonts=not args.no_system_fonts, filters=args.filters,
+                   simplify=simplify)
+    compression = args.compression or "balanced"
+    if fmt == "pdf":
+        options.update(compress=not args.no_compress, compression=compression,
+                       pdf_a=args.pdf_a, images=ImagePolicy(quality=args.quality, jxl=args.jxl))
+    else:
+        options["dpi"] = args.dpi
+        if fmt == "png":
+            options["png"] = PNG(compression, args.quality)
+        elif fmt == "jpeg":
+            options["jpeg"] = JPEG(args.quality or 90, compression)
+        elif fmt == "jxl":
+            options["jxl"] = JXL(args.quality, compression)
+        else:
+            options["avif"] = AVIF(args.quality, compression)
+    try:
+        data = convert(data, format=fmt, **options)
+    except (SVGParseError, RasterizationError, ValueError) as exc:
+        parser.exit(1, f"vec_io: {exc}\n")
+
+    output = args.output
+    if output is None:
+        if args.input == "-":
+            output = "-"
+        else:
+            ext = {"pdf": ".pdf", "png": ".png", "jpeg": ".jpg", "jxl": ".jxl",
+                   "avif": ".avif"}[fmt]
+            output = os.path.splitext(args.input)[0] + ext
+    if output == "-":
+        if sys.stdout is None:  # file descriptor 1 is closed
+            parser.exit(1, "vec_io: cannot write output: standard output is closed\n")
+        try:
+            sys.stdout.buffer.write(data)
+            sys.stdout.buffer.flush()
+        except BrokenPipeError:
+            # The reader went away; keep Python's exit flush from failing too.
+            os.dup2(os.open(os.devnull, os.O_WRONLY), sys.stdout.fileno())
+            return 1
+        except OSError as exc:
+            parser.exit(1, f"vec_io: cannot write output: {exc}\n")
+    else:
+        try:
+            with open(output, "wb") as fh:
+                fh.write(data)
+        except OSError as exc:
+            parser.exit(1, f"vec_io: cannot write output: {exc}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

vec_io/arrays.py

@@ -0,0 +1,83 @@
+"""Array arguments: sequences of numbers (``None`` for missing values) or any object
+exporting the buffer protocol (``array.array``, ``memoryview``, numpy arrays, ...).  Buffers
+are read through :class:`memoryview` and converted in C; numpy is never imported."""
+
+import array
+import math
+import sys
+
+from .native import emit
+
+__all__ = ["doubles", "buffer_shape", "rows", "grid"]
+
+_FORMATS = {"d": ("f", 8), "f": ("f", 4), "b": ("i", 1), "B": ("u", 1), "h": ("i", 2),
+            "H": ("u", 2), "i": ("i", 4), "I": ("u", 4), "l": ("i", 0), "L": ("u", 0),
+            "q": ("i", 8), "Q": ("u", 8), "n": ("i", 0), "N": ("u", 0), "?": ("b", 1)}
+
+
+def _view(value):
+    """A memoryview of ``value`` when it has a numeric buffer, else ``None``."""
+    if isinstance(value, (str, bytes, bytearray)):
+        return None
+    try:
+        mv = memoryview(value)
+    except TypeError:
+        return None
+    fmt = mv.format.lstrip("@=<>!")
+    return mv if fmt in _FORMATS else None
+
+
+def buffer_shape(value):
+    """Shape of a numeric buffer, or ``None`` for other values."""
+    mv = _view(value)
+    return None if mv is None else tuple(mv.shape)
+
+
+def _convert(mv):
+    """All items of a numeric buffer as ``array('d')`` (row-major)."""
+    order = mv.format[0] if mv.format[0] in "@=<>!" else "@"
+    kind, size = _FORMATS[mv.format.lstrip("@=<>!")]
+    size = size or mv.itemsize
+    n = mv.nbytes // mv.itemsize if mv.itemsize else 0
+    little = order in "<" or (order in "@=" and sys.byteorder == "little")
+    if not n:
+        return array.array("d")
+    if kind == "f" and size == 8 and little == (sys.byteorder == "little"):
+        out = array.array("d")
+        out.frombytes(mv.tobytes() if not mv.c_contiguous else mv.cast("B"))
+        return out
+    data = mv if mv.c_contiguous else mv.tobytes()
+    return emit.to_doubles(data, kind, size, little, size, n)
+
+
+def doubles(value):
+    """``value`` (a sequence or a 1-D buffer) as ``array('d')``; ``None`` becomes NaN."""
+    if isinstance(value, array.array) and value.typecode == "d":
+        return value
+    mv = _view(value)
+    if mv is not None:
+        if mv.ndim != 1:
+            raise ValueError("expected a 1-D sequence")
+        return _convert(mv)
+    nan = math.nan
+    return array.array("d", [nan if v is None else float(v) for v in value])
+
+
+def rows(value):
+    """A 2-D buffer as a list of ``array('d')`` rows, or ``None`` for other values."""
+    mv = _view(value)
+    if mv is None or mv.ndim != 2:
+        return None
+    h, w = mv.shape
+    flat = _convert(mv)
+    return [flat[i * w:(i + 1) * w] for i in range(h)]
+
+
+def grid(value):
+    """``(height, width, k, array('d'))`` of a 2-D (k = 1) or 3-D buffer, or ``None``."""
+    mv = _view(value)
+    if mv is None or mv.ndim not in (2, 3):
+        return None
+    h, w = mv.shape[:2]
+    k = mv.shape[2] if mv.ndim == 3 else 1
+    return h, w, k, _convert(mv)