kaleido 0.4.0__py3-none-any.whl

kaleido/__init__.py

@@ -0,0 +1,166 @@
+# don't use scopes!
+from pathlib import Path
+import asyncio
+import base64
+import json
+import sys
+import os
+
+import async_timeout as atimeout
+
+from choreographer import Browser
+
+
+script_path = Path(__file__).resolve().parent / "vendor" / "index.html"
+
+# pdf and eps temporarily disabled
+_all_formats_ = ("png", "jpg", "jpeg", "webp", "svg", "json", "pdf") # eps missing (emf has code but no listed support)
+_text_formats_ = ("svg", "json",) # eps is a text format? :-O
+
+_scope_flags_ = ("plotlyjs", "mathjax", "topojson", "mapbox_access_token")
+
+def to_image_block(spec, f=None, topojson=None, mapbox_token=None, debug=None, tmp_path=None):
+    if debug is None:
+        debug = "KALEIDO-DEBUG" in os.environ or "KALEIDO_DEBUG" in os.environ
+    try:
+        _ = asyncio.get_running_loop()
+        if debug: print("Got running loop, threading", file=sys.stderr)
+        from threading import Thread
+        image = None
+        def get_image():
+            nonlocal image
+            if debug: print("Calling to_image in thread", file=sys.stderr)
+            image = asyncio.run(to_image(spec, f, topojson, mapbox_token, debug=debug, tmp_path=tmp_path))
+        t = Thread(target=get_image)
+        if debug: print("Calling thread start", file=sys.stderr)
+        t.start()
+        t.join()
+        if debug: print("Done with thread", file=sys.stderr)
+        return image
+    except RuntimeError:
+        if debug: print("No loop, no thread", file=sys.stderr)
+        pass
+    return asyncio.run(to_image(spec, f, topojson, mapbox_token, debug=debug, tmp_path=tmp_path))
+
+async def to_image(spec, f=None, topojson=None, mapbox_token=None, debug=None, timeout=60, tmp_path=None):
+    if debug is None:
+        debug = "KALEIDO-DEBUG" in os.environ or "KALEIDO_DEBUG" in os.environ
+    def check_error(res):
+        if 'error' in res:
+            raise RuntimeError(str(res))
+
+    async with (
+            Browser(headless=True, debug=debug, debug_browser=debug, tmp_path=tmp_path) as browser,
+            atimeout.timeout(timeout)):
+        async def print_all(r):
+            print(f"All subscription: {r}", file=sys.stderr)
+        if debug: browser.subscribe("*", print_all)
+        if not f:
+            f = script_path.absolute()
+        if debug: print(f"Creating tab w/ file: {f.as_uri()}", file=sys.stderr)
+        tab = await browser.create_tab(f.as_uri())
+
+        if debug: tab.subscribe("*", print_all)
+        if debug: print("Activating page", file=sys.stderr)
+        res = await tab.send_command("Page.bringToFront")
+        check_error(res)
+
+        page_loaded = tab.subscribe_once("Page.loadEventFired")
+
+        if debug: print("Enabling page", file=sys.stderr)
+        res = await tab.send_command("Page.enable")
+        check_error(res)
+
+        while page_loaded.done():
+            print("Clearing previous loadEventFired", file=sys.stderr)
+            page_loaded = tab.subscribe_once("Page.loadEventFired")
+
+        if debug: print("About to reload page", file=sys.stderr)
+        res = await tab.send_command("Page.reload")
+        check_error(res)
+
+        await page_loaded
+
+        javascript_enabled = tab.subscribe_once("Runtime.executionContextCreated")
+        while javascript_enabled.done():
+            print("Clearing previous executionContextCreated", file=sys.stderr)
+            javascript_enabled = tab.subscribe_once("Runtime.executionContextCreated")
+
+        if debug: print("Enabling runtime", file=sys.stderr)
+        res = await tab.send_command("Runtime.enable")
+        check_error(res)
+
+        if debug: print("Waiting executionContextCreated", file=sys.stderr)
+
+        await javascript_enabled
+        execution_context_id = javascript_enabled.result()["params"]["context"]["id"]
+        # this could just as easily be part of the original script
+        # some changes could be made their to download more easily TODO
+        # read original python, read original javascript
+
+
+        if debug:
+            debug_jsfn = r"function() { return window.KaleidoReport; }"
+            params = dict(
+                    functionDeclaration=debug_jsfn,
+                    returnByValue=True,
+                    executionContextId=execution_context_id)
+            print(await tab.send_command("Runtime.callFunctionOn", params=params), file=sys.stderr)
+
+
+
+        kaleido_jsfn = r"function(spec, ...args) { return kaleido_scopes.plotly(spec, ...args).then(JSON.stringify); }"
+        extra_args = []
+        if topojson:
+            extra_args.append(dict(value=topojson))
+        if mapbox_token:
+            extra_args.append(dict(value=mapbox_token))
+        arguments = [dict(value=spec)]
+        arguments.extend(extra_args)
+        params = dict(
+                functionDeclaration=kaleido_jsfn,
+                arguments=arguments,
+                returnByValue=False,
+                userGesture=True,
+                awaitPromise=True,
+                executionContextId=execution_context_id,
+                )
+        if debug: print("Sending command", file=sys.stderr)
+        response = await tab.send_command("Runtime.callFunctionOn", params=params)
+        check_error(response)
+        # Check for export error, later can customize error messages for plotly Python users
+        code = response.get("code", 0)
+        if code != 0:
+            message = response.get("message", None)
+            raise ValueError(
+                "Transform failed with error code {code}: {message}".format(
+                    code=code, message=message
+                )
+            )
+        try:
+            if debug: print("Loading result", file=sys.stderr)
+            js_response = json.loads(response.get("result").get("result").get("value"))
+            if debug: print(f"Received: {js_response}", file=sys.stderr)
+            response_format = js_response.get("format")
+            img = js_response.get("result")
+        except Exception as e:
+            raise RuntimeError(response) from e
+        if response_format == "pdf":
+            pdf_params = dict(printBackground=True,
+                          marginTop=0,
+                          marginBottom=0,
+                          marginLeft=0,
+                          marginRight=0,
+                          preferCSSPageSize=True,)
+            if debug: print("Sending command to print pdf", file=sys.stderr)
+            pdf_response = await tab.send_command("Page.printToPDF", params=pdf_params)
+            check_error(pdf_response)
+            img = pdf_response.get("result").get("data")
+
+
+        # Base64 decode binary types
+        if response_format not in _text_formats_:
+            img = base64.b64decode(img)
+        else:
+            img = str.encode(img)
+        return img

kaleido/scopes/__init__.py

@@ -0,0 +1,3 @@
+from .plotly import PlotlyScope
+
+__all__ = ['PlotlyScope']

kaleido/scopes/base.py

@@ -0,0 +1,7 @@
+class OldKaleidoError(NotImplementedError):
+    pass
+
+class BaseScope(object):
+    def __init__(self):
+        raise OldKaleidoError("Kaleido no longer uses a scope system, BaseScope should not be used.")
+

kaleido/scopes/plotly.py

@@ -0,0 +1,316 @@
+from __future__ import absolute_import
+import os
+from pathlib import Path
+import tempfile
+import sys
+
+from plotly.graph_objects import Figure
+
+import kaleido # kaleido __init__.py, dislike
+from choreographer import which_browser
+
+# The original kaleido provided a global lock (instead of supporting concurrency)
+# So kaleido 2.0 will as well if it's used from scopes (old api)
+from threading import Lock
+_proc_lock = Lock()
+
+try:
+    from json import JSONDecodeError
+except ImportError:
+    JSONDecodeError = ValueError
+
+class PlotlyScope():
+    """
+    Scope for transforming Plotly figures to static images
+    """
+    _all_formats = kaleido._all_formats_
+    _text_formats = kaleido._text_formats_
+
+    _scope_flags = kaleido._scope_flags_
+
+
+    def __init__(self, plotlyjs=None, mathjax=None, topojson=None, mapbox_access_token=None, debug=None, tmp_path=None, **kwargs):
+        if debug is None:
+            debug = "KALEIDO-DEBUG" in os.environ or "KALEIDO_DEBUG" in os.environ
+        self.debug=debug
+        if tmp_path is None:
+            tmp_path = os.environ.get("KALEIDO_TMP_PATH", None)
+        self._tmp_path = tmp_path
+        # TODO: #2 This is deprecated, this whole FILE is deprecated
+        self._plotlyjs = plotlyjs
+        self._topojson = topojson
+        self._mapbox_access_token = mapbox_access_token
+
+        # Try to find local MathJax, but never fail if something goes wrong
+        try:
+            self._initialize_mathax(mathjax)
+        except: # noqa TODO what would the actual error be
+            self._mathjax = None
+
+        # to_image-level default values
+        self.default_format = "png"
+        self.default_width = 700
+        self.default_height = 500
+        self.default_scale = 1
+
+        self._plotlyfier = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+            'vendor',
+            'kaleido_scopes.js'
+            )
+        path = os.environ.get("BROWSER_PATH", which_browser())
+        if tmp_path:
+            temp_args = dict(dir=self.tmp_path)
+        elif "snap" in path:
+            temp_path = Path.home()
+            if self.debug:
+                print("Snap detected, moving tmp directory to home", file=sys.stderr)
+            temp_args = dict(prefix=".kaleido-", dir=temp_path)
+        else:
+            self._snap = False
+            temp_args = {}
+
+        self._tempdir = tempfile.TemporaryDirectory(**temp_args)
+        if self.debug: print(f"Tempdir: {self._tempdir.name}", file=sys.stderr)
+        self._tempfile = open(f"{self._tempdir.name}/index.html", "w")
+        self._tempfile.write(self.make_page_string())
+        self._tempfile.close()
+
+    def _initialize_mathax(self, mathjax=None):
+        if mathjax is not None:
+            self._mathjax = mathjax
+            return
+
+        vendored_mathjax_path = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+            'vendor',
+            'mathjax',
+            'MathJax.js'
+            )
+        # There is something wild going on w/ mathjax, I think plotly is injecting it?
+        mathjax_path = None
+        if os.path.exists(vendored_mathjax_path):
+            # MathJax is vendored under kaleido/executable.
+            # It was probably install as a PyPI wheel
+            mathjax_path = vendored_mathjax_path
+
+        if mathjax_path:
+            mathjax_uri = Path(mathjax_path).absolute().as_uri()
+            self._mathjax = mathjax_uri
+        else:
+            self._mathjax = None
+
+    def make_page_string(self):
+        page = \
+"""<!DOCTYPE html>
+<html>
+  <head>
+    <style id=\"head-style\"></style>
+    <title>Kaleido-fier</title>
+    <script>
+        window.KaleidoReport = ["start"];
+        function logError(e) {
+            window.KaleidoReport.push("error");
+            window.KaleidoReport.push(e);
+            if (!navigator.onLine) {
+                window.KaleidoReport.push("offline");
+            }
+        }
+    </script>
+    <script>
+      window.PlotlyConfig = {MathJaxConfig: 'local'}
+    </script>
+"""
+        pjs = self._plotlyjs
+        if not pjs:
+            pjs = "https://cdn.plot.ly/plotly-2.35.2.min.js"
+        elif not pjs.startswith("http") and not pjs.startswith("file"):
+            pjs = Path(pjs).absolute().as_uri()
+        page += f" <script src=\"{pjs}\" charset=\"utf-8\" onerror=\"logError('plotly')\"></script>\n"
+
+        if self._mathjax:
+            page += f" <script type=\"text/javascript\" id=\"MathJax-script\" src=\"{self._mathjax}?config=TeX-AMS-MML_SVG\" onerror=\"logError('mathjax')\"></script>\n"
+        page+= \
+f"""    <script src="{Path(self._plotlyfier).absolute().as_uri()}" onerror=\"logError('scoper')\"></script>"""+\
+"""  </head>
+  <body style=\"{margin: 0; padding: 0;}\"><img id=\"kaleido-image\"><img></body>
+</html>"""
+        if self.debug:
+            print("Displaying generated HTML".center(50, "*"), file=sys.stderr)
+            print(page, file=sys.stderr)
+            print("end".center(50, "*"), file=sys.stderr)
+        return page
+
+    @property
+    def scope_name(self):
+        # TODO: #2 This is deprecated
+        return "plotly"
+
+    def make_spec(self, figure, format=None, width=None, height=None, scale=None):
+        # TODO: validate args
+        if isinstance(figure, Figure):
+            figure = figure.to_dict()
+
+        # Apply default format and scale
+        format = format if format is not None else self.default_format
+        scale = scale if scale is not None else self.default_scale
+
+        # Get figure layout
+        layout = figure.get("layout", {})
+
+        # Compute image width / height
+        width = (
+                width
+                or layout.get("width", None)
+                or layout.get("template", {}).get("layout", {}).get("width", None)
+                or self.default_width
+        )
+        height = (
+                height
+                or layout.get("height", None)
+                or layout.get("template", {}).get("layout", {}).get("height", None)
+                or self.default_height
+        )
+
+        # Normalize format
+        original_format = format
+        format = format.lower()
+        if format == 'jpg':
+            format = 'jpeg'
+
+        if format not in self._all_formats:
+            supported_formats_str = repr(list(self._all_formats))
+            raise ValueError(
+                "Invalid format '{original_format}'.\n"
+                "    Supported formats: {supported_formats_str}"
+                .format(
+                    original_format=original_format,
+                    supported_formats_str=supported_formats_str
+                )
+            )
+
+
+        js_args = dict(format=format, width=width, height=height, scale=scale)
+        return dict(js_args, data = figure)
+
+    def transform(self, figure, format=None, width=None, height=None, scale=None, debug=None):
+        """
+        Convert a Plotly figure into a static image
+
+        :param figure: Plotly figure or figure dictionary
+        :param format: The desired image format. One of
+           'png', 'jpg', 'jpeg', 'webp', 'svg', 'pdf', or 'json'.
+
+           If 'json', the following arguments are ignored and a full
+           JSON representation of the figure is returned.
+
+           If not specified, will default to the `scope.default_format` property
+        :param width: The width of the exported image in layout pixels.
+            If the `scale` property is 1.0, this will also be the width
+            of the exported image in physical pixels.
+
+            If not specified, will default to the `scope.default_width` property
+        :param height: The height of the exported image in layout pixels.
+            If the `scale` property is 1.0, this will also be the height
+            of the exported image in physical pixels.
+
+            If not specified, will default to the `scope.default_height` property
+        :param scale: The scale factor to use when exporting the figure.
+            A scale factor larger than 1.0 will increase the image resolution
+            with respect to the figure's layout pixel dimensions. Whereas as
+            scale factor of less than 1.0 will decrease the image resolution.
+
+            If not specified, will default to the `scope.default_scale` property
+        :return: image bytes
+        """
+        if not debug:
+            debug=self.debug
+        spec = self.make_spec(figure, format=format, width=width, height=height, scale=scale)
+
+        # Write to process and read result within a lock so that can be
+        # sure we're reading the response to our request
+        with _proc_lock:
+            img = kaleido.to_image_block(spec, Path(self._tempfile.name).absolute(), self._topojson, self._mapbox_access_token, debug=debug, tmp_path=self._tmp_path)
+
+        return img
+
+    # Flag property methods
+    @property
+    def plotlyjs(self):
+        """
+        URL or local file path to plotly.js bundle to use for image export.
+        If not specified, will default to CDN location.
+        """
+        return self._plotlyjs
+
+    @plotlyjs.setter
+    def plotlyjs(self, val):
+        self._plotlyjs = val
+        self._shutdown_kaleido()
+
+    @property
+    def mathjax(self):
+        """
+        URL to MathJax bundle needed for LaTeX rendering.
+        If not specified, LaTeX rendering support will be disabled.
+        """
+        return self._mathjax
+
+    @mathjax.setter
+    def mathjax(self, val):
+        self._mathjax = val
+        self._shutdown_kaleido()
+
+    @property
+    def topojson(self):
+        """
+        URL to the topojson files needed to render choropleth traces.
+        If not specified, will default to CDN location.
+        """
+        return self._topojson
+
+    @topojson.setter
+    def topojson(self, val):
+        self._topojson = val
+        self._shutdown_kaleido()
+
+    @property
+    def mapbox_access_token(self):
+        """
+        Mapbox access token required to render mapbox layers.
+        If not specified, mapbox layers will only be rendered
+        if a valid token is specified inline in the figure specification
+        """
+        return self._mapbox_access_token
+
+    @mapbox_access_token.setter
+    def mapbox_access_token(self, val):
+        self._mapbox_access_token = val
+        self._shutdown_kaleido()
+
+    def _shutdown_kaleido(self):
+        self._tempfile = open(f"{self._tempdir.name}/index.html", "w")
+        self._tempfile.write(self.make_page_string())
+        self._tempfile.close()
+
+    def __del__(self):
+        try:
+            if os.path.exists(self._tempfile.name):
+                try:
+                    os.remove(self._tempfile.name)
+                except Exception:
+                    pass
+        except Exception:
+            pass
+        try:
+            if os.path.exists(self._tempdir.name):
+                try:
+                    self._tempdir.cleanup()
+                except Exception:
+                    pass
+                try:
+                    os.rmdir(self._tempdir.name)
+                except Exception:
+                    pass
+        except Exception:
+            pass

kaleido/vendor/index.html

@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style id="head-style"></style>
+    <title>Kaleido-fier</title>
+    <script>
+        window.KaleidoReport = ["start"];
+        function logError(e) {
+            window.KaleidoReport.push("error");
+            window.KaleidoReport.push(e);
+            if (!navigator.onLine) {
+                window.KaleidoReport.push("offline");
+            }
+        }
+    </script>
+    <script>
+      window.PlotlyConfig = {MathJaxConfig: 'local'}
+    </script>
+    <script src="https://cdn.plot.ly/plotly-2.35.2.min.js" charset="utf-8" onerror="logError('plotly')"></script>
+    <script type="text/javascript" id="MathJax-script" src="./mathjax/MathJax.js?config=TeX-AMS-MML_SVG" onerror="logError('mathjax')"></script>
+    <script src="./kaleido_scopes.js" onerror="logError('scopes')"></script>
+  </head>
+  <body style="{margin: 0; padding: 0;}"><img id="kaleido-image"><img></body>
+</html>