plotly-print 0.1.0__py3-none-any.whl

plotly_print/__init__.py

@@ -0,0 +1,20 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from plotly_print.core import to_image, to_svg, write_image
+from plotly_print.plotly_hook import patch_plotly, register, unpatch_plotly, unregister
+
+try:
+    __version__ = version('plotly-print')
+except PackageNotFoundError:
+    __version__ = '0.1.0'
+
+__all__ = [
+    'to_svg',
+    'to_image',
+    'write_image',
+    'register',
+    'unregister',
+    'patch_plotly',
+    'unpatch_plotly',
+    '__version__',
+]

plotly_print/core.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import os
+from typing import Any, BinaryIO
+
+from plotly_print.engine import get_engine
+from plotly_print.raster import svg_to_jpeg, svg_to_png, svg_to_webp, write_raster
+
+
+def _extract_figure_spec(fig: Any) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    if hasattr(fig, 'to_dict'):
+        d = fig.to_dict()
+    elif isinstance(fig, dict):
+        d = fig
+    else:
+        raise TypeError(f'Expected plotly.graph_objects.Figure or dict, got {type(fig).__name__}')
+
+    return d.get('data', []), d.get('layout', {})
+
+
+def to_svg(
+    fig: Any,
+    width: int | None = None,
+    height: int | None = None,
+) -> str:
+    data, layout = _extract_figure_spec(fig)
+    return get_engine().render_svg(data, layout, width=width, height=height)
+
+
+def to_image(
+    fig: Any,
+    format: str = 'png',
+    width: int | None = None,
+    height: int | None = None,
+    scale: float = 1.0,
+) -> bytes:
+    fmt = format.lower().strip()
+    svg = to_svg(fig, width=width, height=height)
+
+    if fmt == 'svg':
+        return svg.encode('utf-8')
+    if fmt == 'png':
+        return svg_to_png(svg, width=width, height=height, scale=scale)
+    if fmt in ('jpg', 'jpeg'):
+        return svg_to_jpeg(svg, width=width, height=height, scale=scale)
+    if fmt == 'webp':
+        return svg_to_webp(svg, width=width, height=height, scale=scale)
+    raise ValueError(f"Unsupported format: {format}. Supported: 'svg', 'png', 'jpeg', 'webp'")
+
+
+def write_image(
+    fig: Any,
+    file: str | os.PathLike[str] | BinaryIO,
+    format: str | None = None,
+    scale: float = 1.0,
+    width: int | None = None,
+    height: int | None = None,
+) -> None:
+    if format is None:
+        if isinstance(file, (str, os.PathLike)):
+            ext = os.path.splitext(str(file))[1].lower().lstrip('.')
+            format = ext or 'png'
+        else:
+            format = 'png'
+
+    fmt = format.lower().strip()
+    svg_str = to_svg(fig, width=width, height=height)
+    if fmt == 'svg':
+        if isinstance(file, (str, os.PathLike)):
+            with open(file, 'w', encoding='utf-8') as f:
+                f.write(svg_str)
+        else:
+            file.write(svg_str.encode('utf-8'))
+        return
+
+    write_raster(svg_str, file, format=fmt, width=width, height=height, scale=scale)

plotly_print/engine.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import base64
+import io
+import json
+import re
+import threading
+from pathlib import Path
+from typing import Any
+
+import quickjs
+from PIL import Image, ImageColor, ImageDraw
+from plotly.utils import PlotlyJSONEncoder
+
+from plotly_print.fonts import get_default_font_manager
+
+_JS_DIR = Path(__file__).resolve().parent / 'js'
+_MICRO_DOM_PATH = _JS_DIR / 'micro_dom.js'
+# Official cartesian partial: full plotly.min.js from the plotly package does not load in QuickJS.
+_PLOTLY_JS_PATH = _JS_DIR / 'plotly-cartesian.min.js'
+
+_ENGINE_THREAD_LOCAL = threading.local()
+
+
+def _parse_color(c: str) -> tuple[int, int, int, int] | tuple[int, int, int]:
+    if not c:
+        return (0, 0, 0, 0)
+    c = c.strip()
+    m = re.match(r'rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)(?:\s*,\s*([\d.]+))?\s*\)', c, re.I)
+    if m:
+        r, g, b = int(m.group(1)), int(m.group(2)), int(m.group(3))
+        a = int(float(m.group(4)) * 255) if m.group(4) is not None else 255
+        return (r, g, b, a)
+    try:
+        return ImageColor.getrgb(c)
+    except Exception:
+        return (0, 0, 0, 255)
+
+
+def _encode_canvas_to_png(width: int, height: int, commands_json: str) -> str:
+    w = max(1, int(width))
+    h = max(1, int(height))
+    img = Image.new('RGBA', (w, h), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+    try:
+        commands = json.loads(commands_json)
+    except Exception:
+        commands = []
+
+    for cmd in commands:
+        op = cmd.get('op')
+        if op == 'fillRect':
+            x = cmd.get('x', 0)
+            y = cmd.get('y', 0)
+            cw = cmd.get('w', 0)
+            ch = cmd.get('h', 0)
+            fill = _parse_color(cmd.get('fill', '#000000'))
+            draw.rectangle([x, y, x + cw, y + ch], fill=fill)
+        elif op == 'clearRect':
+            x = cmd.get('x', 0)
+            y = cmd.get('y', 0)
+            cw = cmd.get('w', 0)
+            ch = cmd.get('h', 0)
+            draw.rectangle([x, y, x + cw, y + ch], fill=(0, 0, 0, 0))
+
+    buf = io.BytesIO()
+    img.save(buf, format='PNG')
+    b64 = base64.b64encode(buf.getvalue()).decode('ascii')
+    return f'data:image/png;base64,{b64}'
+
+
+class PrintEngine:
+    def __init__(self) -> None:
+        self.font_manager = get_default_font_manager()
+        self.context = quickjs.Context()
+        self.context.set_max_stack_size(10 * 1024 * 1024)
+
+        self.context.add_callable('_measureTextRaw', self.font_manager.measure_raw)
+        self.context.add_callable('_encodeCanvasToPNG', _encode_canvas_to_png)
+
+        if not _PLOTLY_JS_PATH.is_file():
+            raise FileNotFoundError(f'plotly.js bundle not found at {_PLOTLY_JS_PATH}')
+
+        self.context.eval(_MICRO_DOM_PATH.read_text(encoding='utf-8'))
+        self.context.eval(_PLOTLY_JS_PATH.read_text(encoding='utf-8'))
+
+        self.context.eval("""
+        function plotlyPrintRender(dataJson, layoutJson) {
+            var data = JSON.parse(dataJson);
+            var layout = JSON.parse(layoutJson);
+
+            var w = layout.width || 600;
+            var h = layout.height || 400;
+
+            var container = document.createElement('div');
+            container.id = 'plotly-print-' + Math.random().toString(36).slice(2);
+            container.clientWidth = w;
+            container.clientHeight = h;
+            container.offsetWidth = w;
+            container.offsetHeight = h;
+            container.getBoundingClientRect = function() {
+                return { left: 0, top: 0, right: w, bottom: h, width: w, height: h };
+            };
+            document.body.appendChild(container);
+
+            try {
+                Plotly.newPlot(container, data, layout, { staticPlot: true });
+                var res = null;
+                if (Plotly.Snapshot && typeof Plotly.Snapshot.toSVG === 'function') {
+                    try {
+                        res = Plotly.Snapshot.toSVG(container, 'svg');
+                    } catch(snapErr) {
+                    }
+                }
+                if (!res) {
+                    var svgs = container.querySelectorAll('svg');
+                    if (svgs.length === 0) {
+                        document.body.removeChild(container);
+                        return null;
+                    }
+                    var mainSvg = svgs[0];
+                    for (var s = 1; s < svgs.length; s++) {
+                        var otherSvg = svgs[s];
+                        var kids = otherSvg.childNodes.slice();
+                        for (var k = 0; k < kids.length; k++) {
+                            var kid = kids[k];
+                            if (kid.nodeType === 1 && kid.classList && kid.classList.contains('hoverlayer')) continue;
+                            mainSvg.appendChild(kid);
+                        }
+                    }
+                    res = mainSvg.outerHTML;
+                }
+                if (res) {
+                    res = res.replace(/TOBESTRIPPED/g, "'");
+                }
+                document.body.removeChild(container);
+                return res;
+            } catch(e) {
+                try { document.body.removeChild(container); } catch(ignore) {}
+                throw new Error("Plotly render failed: " + e.message + "\\n" + e.stack);
+            }
+        }
+        """)
+
+    def render_svg(
+        self,
+        data: list[dict[str, Any]],
+        layout: dict[str, Any],
+        width: int | None = None,
+        height: int | None = None,
+    ) -> str:
+        layout_copy = dict(layout) if layout else {}
+        if width is not None:
+            layout_copy['width'] = width
+        if height is not None:
+            layout_copy['height'] = height
+
+        data_json = json.dumps(data, cls=PlotlyJSONEncoder)
+        layout_json = json.dumps(layout_copy, cls=PlotlyJSONEncoder)
+
+        self.context.eval(f'var __plotly_print_data = {json.dumps(data_json)};')
+        self.context.eval(f'var __plotly_print_layout = {json.dumps(layout_json)};')
+        svg = self.context.eval('plotlyPrintRender(__plotly_print_data, __plotly_print_layout);')
+        if not svg:
+            raise RuntimeError('plotly-print rendering failed: No SVG element was generated by Plotly.')
+        return svg
+
+
+def get_engine() -> PrintEngine:
+    if not hasattr(_ENGINE_THREAD_LOCAL, 'engine'):
+        _ENGINE_THREAD_LOCAL.engine = PrintEngine()
+    return _ENGINE_THREAD_LOCAL.engine

plotly_print/fonts.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from PIL import ImageFont
+
+CANDIDATE_FONTS = [
+    '/System/Library/Fonts/Supplemental/Arial.ttf',
+    '/System/Library/Fonts/Helvetica.ttc',
+    '/Library/Fonts/Arial.ttf',
+    '/System/Library/Fonts/SFNSText.ttf',
+    '/System/Library/Fonts/Supplemental/Verdana.ttf',
+    '/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf',
+    '/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf',
+    '/usr/share/fonts/truetype/freefont/FreeSans.ttf',
+    'C:\\Windows\\Fonts\\arial.ttf',
+    'C:\\Windows\\Fonts\\segoeui.ttf',
+]
+
+
+class FontManager:
+    def __init__(self) -> None:
+        self._font_cache: dict[tuple[str, int, str], ImageFont.FreeTypeFont | ImageFont.ImageFont] = {}
+        self._measurement_cache: dict[tuple[str, str, int, str], tuple[float, float, float, float]] = {}
+        self._default_system_font_path = self._find_first_available_font()
+
+    def _find_first_available_font(self) -> str | None:
+        for path in CANDIDATE_FONTS:
+            if Path(path).exists():
+                return path
+        return None
+
+    def get_font(self, family: str, size: float, weight: str = '') -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
+        int_size = max(1, round(size))
+        cache_key = (family.lower().strip(), int_size, weight.lower().strip())
+        if cache_key in self._font_cache:
+            return self._font_cache[cache_key]
+
+        font = None
+        names = [r.strip().strip('"\'').lower() for r in family.split(',')]
+        # Prefer Arial/Helvetica when Plotly's default stack lists verdana with sans-serif.
+        if 'verdana' in names and ('arial' in names or 'sans-serif' in names or 'open sans' in names):
+            names.remove('verdana')
+            names.append('verdana')
+
+        for clean_name in names:
+            if not clean_name or clean_name in ('sans-serif', 'serif', 'monospace'):
+                continue
+
+            for test_name in (clean_name.title(), clean_name.capitalize(), clean_name):
+                try:
+                    font = ImageFont.truetype(test_name, size=int_size)
+                    if font:
+                        break
+                except Exception:
+                    pass
+            if font:
+                break
+
+            for font_path in CANDIDATE_FONTS:
+                base = Path(font_path).name.lower()
+                if base.startswith(clean_name) and Path(font_path).exists():
+                    try:
+                        font = ImageFont.truetype(font_path, size=int_size)
+                        if font:
+                            break
+                    except Exception:
+                        pass
+            if font:
+                break
+
+        if font is None and self._default_system_font_path:
+            try:
+                font = ImageFont.truetype(self._default_system_font_path, size=int_size)
+            except Exception:
+                pass
+
+        if font is None:
+            try:
+                font = ImageFont.load_default(size=int_size)
+            except TypeError:
+                font = ImageFont.load_default()
+
+        self._font_cache[cache_key] = font
+        return font
+
+    def measure(self, text: str, family: str, size: float, weight: str = '') -> tuple[float, float, float, float]:
+        int_size = max(1, round(size))
+        cache_key = (text, family.lower().strip(), int_size, weight.lower().strip())
+        if cache_key in self._measurement_cache:
+            return self._measurement_cache[cache_key]
+
+        if not text:
+            res = (0.0, float(int_size), float(int_size), 0.0)
+            self._measurement_cache[cache_key] = res
+            return res
+
+        font = self.get_font(family, size, weight)
+        try:
+            length = float(font.getlength(text))
+        except Exception:
+            length = float(len(text) * int_size * 0.6)
+
+        try:
+            bbox = font.getbbox(text)
+            try:
+                metrics = font.getmetrics()
+                ascent_val = float(metrics[0])
+                descent_val = float(metrics[1])
+                h = max(ascent_val + descent_val, float(int_size * 1.2))
+                ascent = ascent_val if ascent_val > 0 else float(int_size * 0.8)
+                descent = descent_val if descent_val > 0 else float(int_size * 0.2)
+            except Exception:
+                h = float(int_size * 1.2)
+                ascent = float(int_size * 0.8)
+                descent = float(int_size * 0.2)
+
+            if bbox:
+                w = max(length, float(bbox[2] - bbox[0]))
+            else:
+                w = length
+        except Exception:
+            w, h = length, float(int_size * 1.2)
+            ascent, descent = float(int_size * 0.8), float(int_size * 0.2)
+
+        res = (round(w, 2), round(h, 2), round(ascent, 2), round(descent, 2))
+        self._measurement_cache[cache_key] = res
+        return res
+
+    def measure_raw(self, text: str, family: str, size_str: str, weight: str = '') -> str:
+        try:
+            size = float(size_str)
+        except (ValueError, TypeError):
+            size = 12.0
+        w, h, a, d = self.measure(text, family, size, weight)
+        return f'{w},{h},{a},{d}'
+
+
+_DEFAULT_FONT_MANAGER = FontManager()
+
+
+def get_default_font_manager() -> FontManager:
+    return _DEFAULT_FONT_MANAGER