pdf-io 0.1.0__py3-none-any.whl

pdf_io/__init__.py

@@ -0,0 +1,144 @@
+"""pdf_io: create PDF files with the Python standard library only.
+
+Basic usage::
+
+    from pdf_io import svg_to_pdf, convert_file
+
+    pdf_bytes = svg_to_pdf('<svg xmlns="http://www.w3.org/2000/svg" ...>...</svg>')
+    convert_file("drawing.svg", "drawing.pdf")
+"""
+
+import os
+from collections.abc import Iterable
+from typing import IO, Any
+
+from .canvas import Canvas, Document, LinearGradient, Paint, Pattern, RadialGradient
+from .colormaps import Colormap
+from .colors import CMYK, Color, Spot
+from .document import SVGDocument, SVGParseError
+from .fontdb import FontDB
+from .geometry import Matrix, Path
+from .renderer import render
+from .textlayout import Content, Span, TextLayout
+
+__all__ = ["svg_to_pdf", "svg_to_png", "convert_file", "convert", "SVGParseError",
+           "SVGDocument",
+           "Document", "Canvas", "LinearGradient", "RadialGradient", "Pattern",
+           "Colormap", "CMYK", "Spot", "Matrix", "Path", "Span", "TextLayout",
+           "Color", "Paint", "Content", "__version__"]
+
+__version__ = "0.1.0"
+
+
+def svg_to_pdf(svg: str | bytes, base_dir: str | os.PathLike[str] | None = None,
+               compress: bool = True, font_dirs: Iterable[str | os.PathLike[str]] | None = None,
+               system_fonts: bool = True, filters: bool = False,
+               jpeg_quality: int | None = None, pdf_a: str | None = None) -> bytes:
+    """Convert SVG source to PDF.
+
+    :param svg: SVG document as ``str`` or ``bytes`` (gzip-compressed SVGZ
+        data is accepted too).
+    :param base_dir: directory used to resolve relative file references
+        (``<image href="photo.png">``).  When ``None`` only ``data:`` URIs
+        are loaded.  Otherwise any local file the process can read may be
+        embedded (``../`` paths, absolute paths, ``file:`` URLs), so use
+        ``None`` for untrusted input.
+    :param compress: compress PDF streams with zlib.
+    :param font_dirs: extra directories searched for ``.ttf``/``.otf``/
+        ``.ttc``/``.woff`` fonts (searched before the system directories).
+    :param system_fonts: also use fonts installed on the system.  Disable
+        for output that does not depend on the machine.
+    :param filters: apply SVG filter effects (off by default).  Filtered
+        elements are rasterized, which requires numpy.  A
+        ``data-filters="true|false"`` attribute on an element (inherited by
+        its descendants) overrides this setting.
+    :param jpeg_quality: store rasterized content (``data-rasterize``,
+        filters) as JPEG of this quality (1-100) instead of lossless.  A
+        ``data-jpeg-quality`` attribute overrides it per element.
+    :param pdf_a: ``"2b"``, ``"2u"`` or ``"3b"`` to write a PDF/A file
+        (see :class:`Document`).
+    :returns: the PDF file as ``bytes``.
+    :raises SVGParseError: if the input is not a valid SVG document.
+    """
+    document = SVGDocument(svg)
+    font_db = FontDB(font_dirs=font_dirs, system_fonts=system_fonts)
+    return render(document, base_dir=base_dir, compress=compress, font_db=font_db,
+                  filters=filters, jpeg_quality=jpeg_quality, pdf_a=pdf_a)
+
+
+def svg_to_png(svg: str | bytes, dpi: float = 96, background: Any = None,
+               base_dir: str | os.PathLike[str] | None = None,
+               font_dirs: Iterable[str | os.PathLike[str]] | None = None,
+               system_fonts: bool = True, filters: bool = False) -> bytes:
+    """Render SVG source to PNG bytes (requires numpy).
+
+    ``dpi`` 96 gives one pixel per CSS pixel.  ``background`` is a color, or
+    ``None`` for a transparent image.  ``filters`` enables SVG filter
+    effects (see :func:`svg_to_pdf`).
+    """
+    from .canvas import Document as _Document
+    from .renderer import Renderer, svg_size
+
+    document = SVGDocument(svg)
+    doc = _Document(font_db=FontDB(font_dirs=font_dirs, system_fonts=system_fonts),
+                    base_dir=base_dir, filters=filters)
+    width, height = svg_size(document)
+    page = doc.add_page(width, height, unit="px")
+    Renderer(document, page, base_dir=base_dir).draw()
+    return page.to_png(dpi, background)
+
+
+def convert_file(input_path: str | os.PathLike[str],
+                 output_path: str | os.PathLike[str] | None = None, compress: bool = True,
+                 **options: Any) -> str | os.PathLike[str]:
+    """Convert the SVG file ``input_path`` and write the PDF.
+
+    ``output_path`` defaults to ``input_path`` with a ``.pdf`` extension.
+    Returns the output path.  Extra keyword ``options`` (``base_dir``,
+    ``font_dirs``, ``system_fonts``, ``filters``, ``jpeg_quality``,
+    ``pdf_a``) are passed to :func:`svg_to_pdf`; ``base_dir`` defaults to the
+    directory of ``input_path``.
+    """
+    with open(input_path, "rb") as fh:
+        data = fh.read()
+    if output_path is None:
+        root, _ = os.path.splitext(input_path)
+        output_path = root + ".pdf"
+    options.setdefault("base_dir", os.path.dirname(os.path.abspath(input_path)))
+    pdf = svg_to_pdf(data, compress=compress, **options)
+    with open(output_path, "wb") as fh:
+        fh.write(pdf)
+    return output_path
+
+
+def convert(source: str | bytes | os.PathLike[str] | IO[bytes],
+            output: str | os.PathLike[str] | IO[bytes] | None = None,
+            base_dir: str | os.PathLike[str] | None = None, compress: bool = True,
+            **options: Any) -> bytes:
+    """Flexible conversion helper.
+
+    ``source`` may be SVG text/bytes, a path to an SVG file, or a binary
+    file-like object.  ``output`` may be ``None`` (return bytes), a path, or
+    a binary file-like object.  The PDF bytes are always returned.  Extra
+    keyword ``options`` are passed to :func:`svg_to_pdf`.
+    """
+    if hasattr(source, "read"):
+        data = source.read()
+    elif isinstance(source, (bytes, bytearray)):
+        data = bytes(source)
+    elif isinstance(source, str) and source.lstrip()[:1] == "<":
+        data = source
+    else:
+        path = os.fspath(source)
+        with open(path, "rb") as fh:
+            data = fh.read()
+        if base_dir is None:
+            base_dir = os.path.dirname(os.path.abspath(path))
+    pdf = svg_to_pdf(data, base_dir=base_dir, compress=compress, **options)
+    if output is not None:
+        if hasattr(output, "write"):
+            output.write(pdf)
+        else:
+            with open(os.fspath(output), "wb") as fh:
+                fh.write(pdf)
+    return pdf

pdf_io/__main__.py

@@ -0,0 +1,96 @@
+"""Command line interface: ``python -m pdf_io input.svg [output.pdf]``."""
+
+import argparse
+import os
+import sys
+
+from . import SVGParseError, __version__, svg_to_pdf, svg_to_png
+from .raster import RasterizationError
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="pdf_io", description="Convert an SVG file to PDF (or PNG).")
+    parser.add_argument("input", help="input SVG file, or '-' for stdin")
+    parser.add_argument("output", nargs="?",
+                        help="output PDF file ('-' for stdout); defaults to the "
+                             "input name with a .pdf extension")
+    parser.add_argument("--no-compress", action="store_true",
+                        help="write uncompressed content streams")
+    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; requires numpy)")
+    parser.add_argument("--jpeg-quality", type=int, default=None, metavar="N",
+                        help="store rasterized content as JPEG of quality N (1-100)")
+    parser.add_argument("--pdf-a", choices=["2b", "2u", "3b"], default=None,
+                        help="write a PDF/A file of this conformance level")
+    parser.add_argument("--png", action="store_true",
+                        help="write a PNG image instead of a PDF (requires numpy)")
+    parser.add_argument("--dpi", type=float, default=96,
+                        help="resolution of --png 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")
+    if args.png:
+        pdf_only = [flag for flag, used in (("--pdf-a", args.pdf_a is not None),
+                                            ("--jpeg-quality", args.jpeg_quality is not None),
+                                            ("--no-compress", args.no_compress)) if used]
+        if pdf_only:
+            parser.error(f"{', '.join(pdf_only)} cannot be used with --png")
+
+    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"pdf_io: cannot read input: {exc}\n")
+
+    try:
+        if args.png:
+            pdf = svg_to_png(data, dpi=args.dpi, base_dir=base_dir, font_dirs=args.font_dir,
+                             system_fonts=not args.no_system_fonts, filters=args.filters)
+        else:
+            pdf = svg_to_pdf(data, base_dir=base_dir, compress=not args.no_compress,
+                             font_dirs=args.font_dir, system_fonts=not args.no_system_fonts,
+                             filters=args.filters, jpeg_quality=args.jpeg_quality,
+                             pdf_a=args.pdf_a)
+    except (SVGParseError, RasterizationError, ValueError) as exc:
+        parser.exit(1, f"pdf_io: {exc}\n")
+
+    output = args.output
+    if output is None:
+        if args.input == "-":
+            output = "-"
+        else:
+            output = os.path.splitext(args.input)[0] + (".png" if args.png else ".pdf")
+    if output == "-":
+        if sys.stdout is None:  # file descriptor 1 is closed
+            parser.exit(1, "pdf_io: cannot write output: standard output is closed\n")
+        try:
+            sys.stdout.buffer.write(pdf)
+            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"pdf_io: cannot write output: {exc}\n")
+    else:
+        try:
+            with open(output, "wb") as fh:
+                fh.write(pdf)
+        except OSError as exc:
+            parser.exit(1, f"pdf_io: cannot write output: {exc}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())