tikzplotly 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

tikzplotly/__about__.py

@@ -1,7 +1,7 @@
 """
 Module metadata for tikzplotly.
 """
-__version__ = "0.2.1"
+__version__ = "0.2.3"
 __author__ = "Thomas Saigre"
 __license__ = "MIT"
 __description__ = "Convert plotly figures to TikZ code for inclusion into PGFPlots figures."

tikzplotly/__init__.py

@@ -7,8 +7,16 @@ functions for generating and saving TikZ code from plotly figures.
 Exports:
     get_tikz_code (Callable): Function to generate TikZ code from a plotly figure.
     save (Callable): Function to save TikZ code to a file.
+    show (Callable): Function to show a figure in the browser, with a button exporting it to TikZ.
+
+Importing the package also registers the ``"tikzplotly"`` Plotly renderer, so that
+``fig.show(renderer="tikzplotly")`` adds the same button.
 """
 from .__about__ import __version__, __author__, __license__, __description__
 from ._save import get_tikz_code, save
+from ._browser import show, TikzBrowserRenderer, register_renderer as _register_renderer
+
+_register_renderer()
 
-__all__ = ["__version__", "__author__", "__license__", "__description__", "get_tikz_code", "save"]
+__all__ = ["__version__", "__author__", "__license__", "__description__", "get_tikz_code", "save",
+           "show", "TikzBrowserRenderer"]

tikzplotly/_browser.py

@@ -0,0 +1,346 @@
+"""Show a figure in the web browser with an "Export to TikZ" button in the mode bar.
+
+Plotly's own browser renderer serves the page once and returns, so the page has no way to
+reach Python afterwards. Here a small local HTTP server keeps running while the page is open:
+clicking the button sends the current view (axis ranges, hidden traces) to that server, which
+calls :func:`get_tikz_code` and writes the result to a file.
+
+Plotly itself is not modified: a renderer named ``"tikzplotly"`` is registered with Plotly's
+renderer API when tikzplotly is imported, and :func:`show` is a shortcut to it.
+"""
+import base64
+import json
+import secrets
+import socketserver
+import threading
+import time
+import webbrowser
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import cast
+
+import numpy as np
+import plotly.graph_objects as go
+import plotly.io as pio
+
+from ._save import get_tikz_code
+
+try:  # private module: guarded so that a Plotly reorganisation cannot break ``import tikzplotly``
+    from plotly.io._base_renderers import ExternalRenderer
+except ImportError:  # pragma: no cover
+    ExternalRenderer = object
+
+RENDERER_NAME = "tikzplotly"
+
+# A hidden browser tab may only run its timers once a minute, so the idle timeout has to be
+# well above 60 s, or a tab left in the background would be considered closed.
+PING_MS = 10_000
+IDLE_TIMEOUT = 150
+# Time left after the page signals it is closing, so that a page reload can reconnect.
+CLOSE_GRACE = 5
+
+# "Export to TikZ" icon: a floppy disk with "TikZ" (glyph outlines of Latin Modern Roman Bold),
+# in a 1000x1000 box. A single path, because Plotly only colours the first path of an icon,
+# and its holes need the evenodd fill rule, set in _POST_SCRIPT.
+TIKZ_ICON_PATH = (
+    "M110 40H760L960 240V890Q960 960 890 960H110Q40 960 40 890V110Q40 40 110 40Z M120 115V885H885V275L725"
+    " 115Z M230 115H690V290Q690 320 660 320H260Q230 320 230 290Z M540 155V280H630V155Z M381 604 374 523H1"
+    "47L140 604H156C159 566 162 539 211 539H237V735H185V750C203 749 241 749 260 749C280 749 318 749 336 7"
+    "50V735H284V539H310C358 539 361 566 365 604ZM491 750V735H471V599L412 602V617C432 617 434 617 434 631V"
+    "735H411V750L452 749ZM475 546C475 532 463 520 449 520C435 520 423 532 423 546C423 561 435 572 449 572"
+    "C463 572 475 561 475 546ZM673 701C673 696 668 696 663 696C655 696 655 696 653 705C648 725 641 741 62"
+    "9 741C626 741 621 740 621 729C621 729 621 723 624 712C625 709 625 705 625 702C625 676 596 669 572 66"
+    "6C584 657 596 645 596 644C619 619 634 610 647 610C648 610 652 610 653 614C639 616 630 628 630 639C63"
+    "0 647 636 654 647 654C657 654 671 647 671 625C671 615 667 598 648 598C629 598 612 611 591 634C577 64"
+    "8 571 653 563 658L596 528C596 527 597 525 597 523C597 516 591 517 586 517L545 519C541 519 534 519 53"
+    "4 529C534 535 541 535 544 535C548 535 554 536 558 536L509 731C508 736 508 737 508 739C508 747 514 75"
+    "3 523 753C530 753 540 749 543 739L558 678C568 680 589 685 589 703C589 705 589 707 588 710C588 713 58"
+    "7 715 587 719C587 739 605 753 627 753C661 753 673 703 673 701ZM865 655H849C846 692 842 733 773 733H7"
+    "26L860 536C863 532 863 532 863 528C863 519 859 519 852 519H679L675 601H691C693 556 716 535 763 535H8"
+    "07L672 733C669 737 669 738 669 742C669 750 673 750 680 750H859Z"
+)
+
+_POST_SCRIPT = """
+(function () {
+  var gd = document.getElementById('{plot_id}');
+  var token = '__TOKEN__';
+
+  function post(path, body) {
+    return fetch('/' + token + path, {method: 'POST', body: JSON.stringify(body || {})});
+  }
+
+  function toast(message, failed) {
+    var el = document.createElement('div');
+    el.textContent = message;
+    el.style.cssText = 'position:fixed;left:16px;bottom:16px;padding:8px 12px;z-index:9999;'
+      + 'border-radius:4px;color:#fff;font:13px sans-serif;background:'
+      + (failed ? '#b3261e' : '#2e7d32');
+    document.body.appendChild(el);
+    setTimeout(function () { el.remove(); }, failed ? 8000 : 3000);
+  }
+
+  // Only the view state is sent: the data stays on the Python side.
+  function viewState() {
+    var axes = {};
+    Object.keys(gd.layout).forEach(function (key) {
+      if (/^[xy]axis\\d*$/.test(key)) {
+        var axis = gd.layout[key];
+        axes[key] = axis.autorange ? null : axis.range;
+      }
+    });
+    return {axes: axes, visible: gd.data.map(function (t) { return t.visible; })};
+  }
+
+  var button = {
+    name: 'exportTikz',
+    title: 'Export to TikZ',
+    icon: {width: 1000, height: 1000, path: '__ICON_PATH__'},
+    click: function () {
+      post('/export', viewState())
+        .then(function (r) { return r.json(); })
+        .then(function (r) {
+          if (r.ok) { toast('Saved ' + r.path); } else { toast(r.error, true); }
+        })
+        .catch(function () { toast('The Python process is no longer running', true); });
+    }
+  };
+
+  var style = document.createElement('style');
+  style.textContent = '.modebar-btn[data-title="Export to TikZ"] path { fill-rule: evenodd; }';
+  document.head.appendChild(style);
+
+  var config = __CONFIG__;
+  config.modeBarButtonsToAdd = (config.modeBarButtonsToAdd || []).concat([button]);
+  Plotly.react(gd, gd.data, gd.layout, config);
+
+  // Immediate ping: after a reload, cancels the "closing" signal sent by the previous page.
+  post('/ping');
+  setInterval(function () { post('/ping'); }, __PING_MS__);
+  window.addEventListener('pagehide', function () {
+    navigator.sendBeacon('/' + token + '/closing');
+  });
+})();
+"""
+
+
+def _decode_arrays(obj):
+    """Turn Plotly's ``{"dtype": ..., "bdata": ...}`` entries back into NumPy arrays.
+
+    Since Plotly 6, ``Figure.to_dict()``, hence the dict a renderer receives, stores NumPy
+    arrays in this base64 form, which the rest of tikzplotly cannot index.
+    """
+    if isinstance(obj, dict):
+        if "bdata" in obj and "dtype" in obj:
+            array = np.frombuffer(base64.b64decode(obj["bdata"]), dtype=obj["dtype"])
+            if "shape" in obj:
+                shape = obj["shape"]
+                if isinstance(shape, str):
+                    shape = [int(n) for n in shape.split(",")]
+                array = array.reshape(shape)
+            return array
+        return {key: _decode_arrays(value) for key, value in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_decode_arrays(value) for value in obj]
+    return obj
+
+
+class _LocalServer(ThreadingHTTPServer):
+    """HTTP server that does not look up its host name.
+
+    ``HTTPServer.server_bind`` calls ``socket.getfqdn``, a reverse DNS lookup that can take
+    several seconds, notably on macOS. The name is not used here.
+    """
+
+    def server_bind(self):
+        socketserver.TCPServer.server_bind(self)
+        self.server_name, self.server_port = self.server_address[:2]    # type: ignore
+
+
+def _free_path(path: Path) -> Path:
+    """Return ``path``, or ``stem_1.ext``, ``stem_2.ext``, ... if it already exists."""
+    candidate, n = path, 0
+    while candidate.exists():
+        n += 1
+        candidate = path.with_name(f"{path.stem}_{n}{path.suffix}")
+    return candidate
+
+
+class TikzBrowserRenderer(ExternalRenderer):    # type: ignore
+    """Plotly renderer opening the figure in the browser with an "Export to TikZ" button.
+
+    Parameters
+    ----------
+    output, optional
+        file written by the button, by default ``"figure.tex"``. If it already exists,
+        ``figure_1.tex``, ``figure_2.tex``, ... are used instead, so no export is overwritten.
+    config, optional
+        Plotly config dict for the page (see ``fig.show(config=...)``), by default None
+    **tikz_options
+        passed on to :func:`get_tikz_code` (``tikz_options``, ``axis_options``, ``decimate``...).
+        Unless ``img_name`` is given, the image of a heatmap is saved next to the ``.tex`` file,
+        with the same name.
+    """
+
+    def __init__(self, output="figure.tex", config=None, **tikz_options):
+        self.output = Path(output)
+        self.config = dict(config or {})
+        self.tikz_options = tikz_options
+        self._lock = threading.Lock()
+
+    def export(self, fig, view=None) -> Path:
+        """Write the TikZ code of ``fig``, as currently displayed in the page, to a free file name.
+
+        Parameters
+        ----------
+        fig
+            Plotly figure, or figure dict as received by a renderer
+        view, optional
+            ``{"axes": {"xaxis": [min, max] or None, ...}, "visible": [...]}`` as sent by the page
+
+        Returns
+        -------
+            path of the written file
+        """
+        view = view or {}
+        fig = go.Figure(_decode_arrays(fig) if isinstance(fig, dict) else fig)  # copy: fig is reused
+        for name, axis_range in (view.get("axes") or {}).items():
+            fig.layout[name].range = axis_range
+        states = view.get("visible") or []
+        if len(states) == len(fig.data):  # get_tikz_code exports hidden traces too
+            fig.data = [trace for trace, state in zip(fig.data, states) if state in (None, True)]
+
+        with self._lock:  # two quick clicks must not pick the same file name
+            path = _free_path(self.output)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            options = {"img_name": str(path.with_suffix(".png")), **self.tikz_options}
+            path.write_text(get_tikz_code(fig, **options), encoding="utf-8")
+        return path
+
+    def start_server(self, fig):
+        """Start serving the page for ``fig`` without opening a browser.
+
+        Returns
+        -------
+            ``(url, thread)``: the page's address, and the thread serving it, which ends once the
+            page has been closed or has not been heard from for ``IDLE_TIMEOUT`` seconds
+        """
+        if not isinstance(fig, dict):
+            fig = go.Figure(fig)  # snapshot: later changes made by the script are not exported
+        fig_dict = fig if isinstance(fig, dict) else fig.to_dict()
+        token = secrets.token_urlsafe(24)
+        script = (_POST_SCRIPT.replace("__TOKEN__", token)
+                  .replace("__CONFIG__", json.dumps(self.config))
+                  .replace("__PING_MS__", str(PING_MS))
+                  .replace("__ICON_PATH__", TIKZ_ICON_PATH))
+        html = pio.to_html(
+            fig_dict, config=self.config, include_plotlyjs=True,
+            include_mathjax="cdn", post_script=script, full_html=True,      # type: ignore[reportArgumentType]
+            default_width="100%", default_height="100%", validate=False,
+        ).encode("utf-8")
+
+        renderer = self
+        state = {}
+
+        class Handler(BaseHTTPRequestHandler):
+            """Serves the page, and answers the requests sent by its script."""
+
+            def _reply(self, status, body, ctype="application/json"):
+                self.send_response(status)
+                self.send_header("Content-Type", ctype)
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+
+            def _host_ok(self):
+                # Rejects DNS rebinding: a remote site reaching this server under its own name.
+                server = cast(ThreadingHTTPServer, self.server)
+                return self.headers.get("Host") == f"127.0.0.1:{server.server_port}"
+
+            def do_GET(self):  # pylint: disable=invalid-name
+                """Serve the page."""
+                if not self._host_ok() or self.path != "/":
+                    self._reply(403, b"{}")
+                    return
+                state["deadline"] = time.monotonic() + IDLE_TIMEOUT
+                self._reply(200, html, "text/html; charset=utf-8")
+
+            def do_POST(self):  # pylint: disable=invalid-name
+                """Handle ``/<token>/ping``, ``/<token>/closing`` and ``/<token>/export``."""
+                raw = self.rfile.read(int(self.headers.get("Content-Length") or 0))
+                prefix = f"/{token}/"
+                if not self._host_ok() or not self.path.startswith(prefix):
+                    self._reply(403, b"{}")
+                    return
+                action = self.path[len(prefix):]
+                if action == "closing":
+                    state["deadline"] = time.monotonic() + CLOSE_GRACE
+                    self._reply(200, b"{}")
+                    return
+                state["deadline"] = time.monotonic() + IDLE_TIMEOUT
+                if action == "ping":
+                    self._reply(200, b"{}")
+                    return
+                if action != "export":
+                    self._reply(404, b"{}")
+                    return
+                try:
+                    path = renderer.export(fig, json.loads(raw or b"{}"))
+                    result = {"ok": True, "path": str(path)}
+                except Exception as exc:  # pylint: disable=broad-exception-caught  # shown in the page
+                    result = {"ok": False, "error": f"{type(exc).__name__}: {exc}"}
+                self._reply(200, json.dumps(result).encode("utf-8"))
+
+            def log_message(self, format, *args):  # pylint: disable=redefined-builtin
+                pass
+
+        server = _LocalServer(("127.0.0.1", 0), Handler)
+        server.timeout = 0.5
+        state["deadline"] = time.monotonic() + IDLE_TIMEOUT  # counted from when the server is ready
+
+        def serve():
+            while time.monotonic() < state["deadline"]:
+                server.handle_request()
+            server.server_close()
+
+        # Not a daemon thread: the script may reach its end while the page is still open,
+        # and the button has to keep working until the page is closed.
+        thread = threading.Thread(target=serve, name="tikzplotly-browser", daemon=False)
+        thread.start()
+        return f"http://127.0.0.1:{server.server_port}/", thread
+
+    def render(self, fig_dict):
+        """Called by Plotly, for ``fig.show(renderer="tikzplotly")``."""
+        url, _ = self.start_server(fig_dict)
+        webbrowser.open(url)
+
+
+def show(fig, output="figure.tex", config=None, **tikz_options):
+    """Show a figure in the web browser, with an "Export to TikZ" button in its mode bar.
+
+    Each click on the button writes the TikZ code of the figure, as currently displayed (zoom,
+    traces hidden from the legend), to ``output``, or to ``output_1.tex``, ``output_2.tex``, ...
+    if that file already exists. The Python process keeps running while the page is open,
+    and stops a few seconds after it is closed.
+
+    Parameters
+    ----------
+    fig
+        Plotly figure
+    output, optional
+        file written by the button, by default ``"figure.tex"``
+    config, optional
+        Plotly config dict for the page, by default None
+    **tikz_options
+        passed on to :func:`get_tikz_code` (``tikz_options``, ``axis_options``, ``decimate``...)
+    """
+    renderer = TikzBrowserRenderer(output, config=config, **tikz_options)
+    url, _ = renderer.start_server(fig)
+    webbrowser.open(url)
+
+
+def register_renderer():
+    """Register the ``"tikzplotly"`` renderer with Plotly, so ``fig.show(renderer="tikzplotly")`` works."""
+    if ExternalRenderer is object:  # pragma: no cover
+        return
+    if RENDERER_NAME not in pio.renderers:
+        pio.renderers[RENDERER_NAME] = TikzBrowserRenderer()

tikzplotly/_color.py

@@ -30,7 +30,7 @@ def convert_color(color):
         string from plotly color palette, can be one of the following:
         - hex string : "#______"
         - rgb string : "rgb(__, __, __)" with values between 0 and 255
-        - rgba string : "rgba(__, __, __, __)" with values between 0 and 255 and an opacity value between 0 and 1
+        - rgba string : "rgba(__, __, __[, __])" with values between 0 and 255 and an opacity value between 0 and 1 (optional)
         - color name : "red", "green", "blue", "yellow", "orange", "purple", "brown", "black", "gray", "white" or any other color name from
                         https://github.com/plotly/plotly.py/blob/main/templategen/utils/colors.py
 
@@ -45,20 +45,21 @@ def convert_color(color):
     if color is None:
         return None, None, None, 1
     if isinstance(color, numpy.ndarray):
-        warn("Color from data is not supported yet. Returning the default color: blue.")
-        return "blue", "HTML", "0000ff", 1
+        warn("Color from data is not supported yet. Returning no color.")
+        return None, None, None, 1
     if not isinstance(color, str):
-        warn(f"Color {color} type '{color.__class__.__name__}' is not supported yet. Returning the default color: blue.")
-        return "blue", "HTML", "0000ff", 1
+        warn(f"Color {color} type '{color.__class__.__name__}' is not supported yet. Returning no color.")
+        return None, None, None, 1
 
     if color.startswith("#"):
         return color[1:], "HTML", color[1:], 1
 
     if color.startswith("rgba"):
-        sp = color.split("(")[1].split(",")
-        rgb_color = sp[:-1]
-        rgb_color = convert_color(f"rgb({rgb_color[0]},{rgb_color[1]},{rgb_color[2]})")[:-1]
-        return rgb_color + (float(sp[-1][:-1]),)
+        sp = color.split("(")[1].replace(')', '').split(",")
+        rgb_color = [s.strip() for s in sp]
+        r, g, b = int(rgb_color[0]), int(rgb_color[1]), int(rgb_color[2])
+        opacity = float(rgb_color[3]) if len(rgb_color) == 4 else 1.0
+        return hashlib.sha1(f"{r}, {g}, {b}".encode('UTF-8')).hexdigest()[:10], "RGB", rgb_str(r, g, b), opacity
 
     if color.startswith("rgb"):
         color = color[4:-1].replace("[", "{").replace("]", "}")

tikzplotly/{_dataContainer.py → _data_container.py}

@@ -46,7 +46,7 @@ class Data:
     """Class to handle data in TikZ plots.
     """
 
-    def __init__(self, name, x):
+    def __init__(self, name, x, decimate: int|None=None):
         """Initialize a Data object.
 
         Parameters
@@ -59,6 +59,8 @@ class Data:
         self.name = name
         self.macro_name = "\\" + replace_all_digits(name)
         self.x = x
+        # decimate: None means keep all points, otherwise integer >= 1
+        self.decimate = decimate
         self.y_label = []
         self.y_data = []
 
@@ -84,7 +86,7 @@ class Data:
 class Data3D:
     """Handle 3D data in Tikz plots
     """
-    def __init__(self, x, y, z, name):
+    def __init__(self, x, y, z, name, decimate: int|None=None):
         """Initialize the Data3D object
 
         Parameters
@@ -101,6 +103,8 @@ class Data3D:
         self.x = np.array(x)
         self.y = np.array(y)
         self.z = np.array(z)
+        # decimate: None means keep all points, otherwise integer >= 1
+        self.decimate = decimate
         if name:
             self.name = sanitize_text(name, keep_space=0)
         else:
@@ -128,7 +132,7 @@ class DataContainer:
     def __init__(self):
         self.data = []
 
-    def add_data(self, x, y, name=None, y_label=None):
+    def add_data(self, x, y, name=None, y_label=None, decimate: int|None=None):
         """Add data to the container.
 
         Parameters
@@ -141,11 +145,16 @@ class DataContainer:
             name of the y data, by default None
         name, optional
             name of the data, by default None
+        decimate, optional
+            number of data to keep, all of them if None, by default None.
 
         Returns
         -------
             tuple (macro_name, y_label), where macro_name is the name of the data in LaTeX and y_label the name of the y data in LaTeX
         """
+        if decimate is not None and (not isinstance(decimate, int) or decimate < 1):
+            raise ValueError("decimate must be None or an integer >= 1")
+
         for data in self.data:
             if len(data.x) != len(x):
                 continue
@@ -157,12 +166,12 @@ class DataContainer:
             elif hasattr(are_equals, "all") and are_equals.all():
                 y_label_val = data.add_y_data(y, y_label or name)
                 return data.macro_name, treat_data(y_label_val)
-        data_to_add = Data(f"data{index_to_letters(len(self.data))}", x)
+        data_to_add = Data(f"data{index_to_letters(len(self.data))}", x, decimate=decimate)
         y_label_val = data_to_add.add_y_data(y, y_label or name)
         self.data.append(data_to_add)
         return data_to_add.macro_name, treat_data(y_label_val)
 
-    def add_data3d(self, x, y, z, name=None):
+    def add_data3d(self, x, y, z, name=None, decimate: int|None=None):
         """Add data to the container.
 
         Parameters
@@ -175,18 +184,23 @@ class DataContainer:
             z values of the data
         name, optional
             name of the data, by default None
+        decimate, optional
+            number of data to keep, all of them if None, by default None.
 
         Returns
         -------
             tuple (macro_name, z_name), where macro_name is the name of the data in LaTeX and z_name the name of the z data in LaTeX
         """
+        if decimate is not None and (not isinstance(decimate, int) or decimate < 1):
+            raise ValueError("decimate must be None or an integer >= 1")
+
         for data in self.data:
             if hasattr(data, "x") and hasattr(data, "y") and hasattr(data, "z"):
                 if np.array_equal(data.x, x) and np.array_equal(data.y, y) and np.array_equal(data.z, z):
                     return data.name, data.z_name
-        data_obj = Data3D(x, y, z, name)
+        data_obj = Data3D(x, y, z, name, decimate=decimate)
         self.data.append(data_obj)
-        return data_obj.name, data_obj.z_name
+        return data_obj.name
 
     def export_data(self):
         """Generate LaTeX code to export the data from DataContainer.
@@ -202,8 +216,20 @@ class DataContainer:
             if hasattr(data, "z"):
                 export_string += "\\pgfplotstableread{\n"
                 export_string += "x y z\n"
-                for x, y, z in zip(data.x, data.y, data.z):
-                    export_string += f"{treat_data(x)} {treat_data(y)} {treat_data(z)}\n"
+                n = len(data.x)
+                if getattr(data, 'decimate', None) is None:
+                    indices = range(n)
+                else:
+                    d = data.decimate
+                    if d <= 1:
+                        indices = range(n)
+                    else:
+                        # always include first and last
+                        indices = list(range(0, n, d))
+                        if indices[-1] != n-1:
+                            indices.append(n-1)
+                for i in indices:
+                    export_string += f"{treat_data(data.x[i])} {treat_data(data.y[i])} {treat_data(data.z[i])}\n"
                 export_string += f"}}{{\\{data.name}}}\n"
 
             # 2D
@@ -216,8 +242,19 @@ class DataContainer:
                 else:
                     header += " y"
                 export_string += header + "\n"
-                for i, x in enumerate(data.x):
-                    row = [treat_data(x)]
+                n = len(data.x)
+                if getattr(data, 'decimate', None) is None:
+                    indices = range(n)
+                else:
+                    d = data.decimate
+                    if d <= 1:
+                        indices = range(n)
+                    else:
+                        indices = list(range(0, n, d))
+                        if indices[-1] != n-1:
+                            indices.append(n-1)
+                for i in indices:
+                    row = [treat_data(data.x[i])]
                     for y_col in data.y_data:
                         row.append(treat_data(y_col[i]))
                     export_string += " ".join(row) + "\n"

tikzplotly/_heatmap.py

@@ -102,9 +102,10 @@ def draw_heatmap(data, fig, img_name, axis: Axis):
 
     img_bytes = fig_copy.to_image(format="png")  # The image created by plotly keeps places around the heatmap
     cropped_image = crop_image(Image.open(io.BytesIO(img_bytes)))   # so we crop all the white around the figure
-    resized_image = resize_image(cropped_image, *figure_data.shape)  # and we resize it so each square is a 1px x 1px square
+    resized_image = resize_image(cropped_image, *figure_data.shape) # and we resize it so each square is a 1px x 1px square
 
-    os.makedirs(os.path.dirname(img_name), exist_ok=True) # Make sure the directory exists
+    dirname = os.path.dirname(img_name) or '.'  # Ensure that dirname is not empty
+    os.makedirs(dirname, exist_ok=True)         # Make sure the directory exists
     resized_image.save(img_name)
 
 

tikzplotly/_histogram.py

@@ -50,6 +50,27 @@ def formalize_data(data, axis:Axis, row_sep="\\\\"):
 
     return data_str
 
+def treat_histnorm(histnorm: str, hist_options: dict):
+    """Handle the normalization option of the histogram
+
+    Parameters
+    ----------
+    histnorm : str
+        The normalization mode for the histogram.
+    hist_options : dict
+        Dictionary to store histogram options.
+    """
+    if histnorm in ("percent", "probability", "density"):
+        warn(
+            f"Sorry, I did not find an equivalent for histnorm='{histnorm}' in TikZ. "
+            "If you need this feature implemented, please open an issue, if possible with a MWE pgfplots code "
+            "that would plot this :).\nFor now, the histogram will be plotted without normalization "
+            "(as if histnorm='probability density')."
+        )
+        hist_options["density"] = None
+    elif histnorm in ("probability density", ):
+        hist_options["density"] = None
+
 def draw_histogram(trace, axis: Axis, colors_set, row_sep="\\\\"):
     """
     Draw a histogram and return the TikZ code.
@@ -79,7 +100,8 @@ def draw_histogram(trace, axis: Axis, colors_set, row_sep="\\\\"):
 
     code = ""
 
-    plot_options = {"hist": None}
+    plot_options = {}
+    plot_options["hist"] = None
     type_options = {"row sep": row_sep, "y index": 0}
     hist_options = {}
 
@@ -92,36 +114,15 @@ def draw_histogram(trace, axis: Axis, colors_set, row_sep="\\\\"):
         axis.add_option("x filter/.expression", "rawy")
         axis.add_option("y filter/.expression", "rawx")
         hist_options["handler/.style"] = "{xbar interval}"
-
+    else:   # trace.x and trace.y are both empty
+        warn("Empty histogram. Returning no plot")
+        return ""
 
 
     if trace.nbinsx is not None:
         hist_options["bins"] = trace.nbinsx
 
-    if trace.histnorm == "percent":
-        warn(
-            f"Sorry, I did not find an equivalent for histnorm='{trace.histnorm}' in TikZ. "
-            "If you need this feature implemented, please open an issue, if possible with a MWE pgfplots code "
-            "that would plot this :).\nFor now, the histogram will be plotted without normalization "
-            "(as if histnorm='probability density')."
-        )
-        hist_options["density"] = None
-    elif trace.histnorm == "probability":
-        warn(
-            f"Sorry, I did not find an equivalent for histnorm='{trace.histnorm}' in TikZ. "
-            "If you need this feature implemented, please open an issue, if possible with a MWE pgfplots code that would plot this :).\n"
-            "For now, the histogram will be plotted without normalization (as if histnorm='probability density')."
-        )
-        hist_options["density"] = None
-    elif trace.histnorm == "density":
-        warn(
-            f"Sorry, I did not find an equivalent for histnorm='{trace.histnorm}' in TikZ. "
-            "If you need this feature implemented, please open an issue, if possible with a MWE pgfplots code that would plot this :).\n"
-            "For now, the histogram will be plotted without normalization (as if histnorm='probability density')."
-        )
-        hist_options["density"] = None
-    elif trace.histnorm == "probability density":
-        hist_options["density"] = None
+    treat_histnorm(trace.histnorm, hist_options)
 
     if trace.cumulative.enabled:
         hist_options["cumulative"] = None
@@ -152,5 +153,4 @@ def draw_histogram(trace, axis: Axis, colors_set, row_sep="\\\\"):
     code += tex_addplot(data_str, plot_type = "table",
                         options = option_dict_to_str(plot_options), type_options=option_dict_to_str(type_options))
 
-
     return code

tikzplotly/_polar.py

@@ -7,7 +7,7 @@ from ._axis import Axis
 from ._utils import option_dict_to_str
 from ._tex import tex_addplot
 from ._color import convert_color
-from ._dataContainer import DataContainer
+from ._data_container import DataContainer
 
 def get_polar_coord(trace, axis: Axis, data_container: DataContainer):
     """Get polar coordinates from the trace

tikzplotly/_save.py

@@ -19,16 +19,17 @@ from ._polar import get_polar_coord, draw_scatterpolar
 from ._axis import Axis
 from ._color import convert_color
 from ._annotations import str_from_annotation
-from ._dataContainer import DataContainer
+from ._data_container import DataContainer
 from ._utils import sanitize_tex_text, sanitize_text
 
 
 def get_tikz_code(
         fig,
-        tikz_options = None,
-        axis_options = None,
-        include_disclamer = True,
-        img_name = "heatmap.png",
+        tikz_options: dict | None = None,
+        axis_options: dict | None = None,
+        include_disclamer: bool = True,
+        img_name: str = "heatmap.png",
+        decimate: int | None = None,
     ):
     """Get the tikz code of a figure.
 
@@ -74,17 +75,17 @@ def get_tikz_code(
             if trace.y is None:
                 trace.y = list(range(len(trace.x)))
 
-            data_name_macro, y_name = data_container.add_data(trace.x, trace.y, trace.name)
+            data_name_macro, y_name = data_container.add_data(trace.x, trace.y, trace.name, decimate=decimate)
 
             # If x is textual => symbolic x coords
             if all(isinstance(v, str) for v in trace.x):
-                sanitized_trace_x = [sanitize_text(x, keep_space=-1) for x in trace.x]
+                sanitized_trace_x = [sanitize_text(str(x), keep_space=-1) for x in trace.x]
                 axis.add_option("symbolic x coords", "{" + ",".join(sanitized_trace_x) + "}")
                 axis.add_option("xtick", "data")
 
             # If y is textual => symbolic y coords
             if all(isinstance(v, str) for v in trace.y):
-                sanitized_trace_y = [sanitize_text(y, keep_space=-1) for y in trace.y]
+                sanitized_trace_y = [sanitize_text(str(y), keep_space=-1) for y in trace.y]
                 axis.add_option("symbolic y coords", "{" + ",".join(sanitized_trace_y) + "}")
                 axis.add_option("ytick", "data")
 
@@ -173,7 +174,7 @@ def get_tikz_code(
             if hasattr(figure_layout.scene, "title") and getattr(figure_layout.scene.title, "text", None):
                 axis.add_option("title", f"{{{sanitize_tex_text(figure_layout.scene.title.text)}}}")
 
-            data_name_macro, z_name = data_container.add_data3d(trace.x, trace.y, trace.z, trace.name)
+            data_name_macro = data_container.add_data3d(trace.x, trace.y, trace.z, trace.name, decimate=decimate)
             data_str.append(draw_scatter3d(data_name_macro, trace, colors_set))
 
             if trace.name and trace['showlegend'] is not False:
@@ -228,7 +229,7 @@ def get_tikz_code(
     return code
 
 
-def save(filepath, *args, **kwargs):
+def save(filepath: str | Path, *args, **kwargs):
     """Save a figure to a file or a stream.
 
     Parameters

tikzplotly/_scatter.py

@@ -2,16 +2,16 @@
 Provides functionality to convert Plotly scatter traces into TikZ/PGFPlots code for LaTeX documents.
 """
 
-from warnings import warn
 import numpy as np
 from ._tex import tex_addplot, tex_add_text
 from ._color import convert_color
-from ._marker import marker_symbol_to_tex
 from ._dash import DASH_PATTERN
 from ._axis import Axis
 from ._data import data_type
+from ._trace_utils import configure_marker_options, finalize_marker_options
 from ._utils import px_to_pt, option_dict_to_str
 
+
 def draw_scatter2d(data_name, scatter, y_name, axis: Axis, color_set):
     """Get code for a scatter trace.
 
@@ -53,15 +53,8 @@ def draw_scatter2d(data_name, scatter, y_name, axis: Axis, color_set):
     options_dict = {}
     mark_option_dict = {}
 
-    if mode == "markers":
-        if marker.symbol is not None:
-            symbol, symbol_options = marker_symbol_to_tex(marker.symbol)
-            options_dict["mark"] = symbol
-            options_dict["only marks"] = None
-            if symbol_options is not None:
-                mark_option_dict[symbol_options[0]] = symbol_options[1]
-        else:
-            options_dict["only marks"] = None
+    if "markers" in mode:
+        configure_marker_options(mode, marker, options_dict, mark_option_dict, color_set)
 
         if scatter.marker.size is not None:
             options_dict["mark size"] = px_to_pt(marker.size)
@@ -71,14 +64,7 @@ def draw_scatter2d(data_name, scatter, y_name, axis: Axis, color_set):
             mark_option_dict["solid"] = None
             mark_option_dict["fill"] = convert_color(scatter.marker.color)[0]
 
-        if (line:=scatter.marker.line) is not None:
-            if line.color is not None:
-                color_set.add(convert_color(line.color)[:3])
-                mark_option_dict["draw"] = convert_color(line.color)[0]
-            if line.width is not None:
-                mark_option_dict["line width"] = px_to_pt(line.width)
-
-        if (angle:=scatter.marker.angle) is not None:
+        if (angle := scatter.marker.angle) is not None:
             mark_option_dict["rotate"] = angle
 
         if (opacity := scatter.opacity) is not None:
@@ -86,22 +72,7 @@ def draw_scatter2d(data_name, scatter, y_name, axis: Axis, color_set):
         if (opacity := scatter.marker.opacity) is not None:
             mark_option_dict["opacity"] = np.round(opacity, 2)
 
-        if mark_option_dict:
-            mark_options = option_dict_to_str(mark_option_dict)
-            options_dict["mark options"] = f"{{{mark_options}}}"
-
-    elif mode == "lines":
-        options_dict["mark"] = "none"
-
-    elif "lines" in mode and "markers" in mode:
-        if marker.symbol is not None:
-            symbol, symbol_options = marker_symbol_to_tex(marker.symbol)
-            options_dict["mark"] = symbol
-            if symbol_options is not None:
-                mark_option_dict[symbol_options[0]] = symbol_options[1]
-
-    else:
-        warn(f"Scatter : Mode {mode} is not supported yet.")
+    finalize_marker_options(mode, options_dict, mark_option_dict, "Scatter")
 
     if scatter.line.width is not None:
         options_dict["line width"] = px_to_pt(scatter.line.width)
@@ -110,7 +81,6 @@ def draw_scatter2d(data_name, scatter, y_name, axis: Axis, color_set):
     if scatter.connectgaps in [False, None] and None in scatter.x:
         options_dict["unbounded coords"] = "jump"
 
-
     if scatter.line.color is not None:
         options_dict["color"] = convert_color(scatter.line.color)[0]
         if "mark" in mode:

tikzplotly/_scatter3d.py

@@ -1,12 +1,13 @@
 """
 Provides functionality to convert Plotly 3D scatter traces into TikZ/PGFPlots code for LaTeX documents.
 """
-from warnings import warn
+
 import numpy as np
 from ._color import convert_color
-from ._marker import marker_symbol_to_tex
+from ._trace_utils import configure_marker_options, finalize_marker_options
 from ._utils import px_to_pt, option_dict_to_str
 
+
 def draw_scatter3d(data_name, scatter, color_set):
     """
     Get code for a scatter3d trace.
@@ -28,16 +29,8 @@ def draw_scatter3d(data_name, scatter, color_set):
     options_dict = {}
     mark_option_dict = {}
 
-    # Markers only
-    if mode == "markers":
-        if marker.symbol is not None:
-            symbol, symbol_options = marker_symbol_to_tex(marker.symbol)
-            options_dict["mark"] = symbol
-            options_dict["only marks"] = None
-            if symbol_options is not None:
-                mark_option_dict[symbol_options[0]] = symbol_options[1]
-        else:
-            options_dict["only marks"] = None
+    if "markers" in mode:
+        configure_marker_options(mode, marker, options_dict, mark_option_dict, color_set)
 
         if marker.size is not None:
             size = marker.size
@@ -53,34 +46,12 @@ def draw_scatter3d(data_name, scatter, color_set):
             mark_option_dict["solid"] = None
             mark_option_dict["fill"] = convert_color(c)[0]
 
-        if (line := marker.line) is not None:
-            if line.color is not None:
-                color_set.add(convert_color(line.color)[:3])
-                mark_option_dict["draw"] = convert_color(line.color)[0]
-            if line.width is not None:
-                mark_option_dict["line width"] = px_to_pt(line.width)
-
         if (opacity := scatter.opacity) is not None:
             options_dict["opacity"] = opacity
         if (opacity := marker.opacity) is not None:
             mark_option_dict["opacity"] = opacity
 
-        if mark_option_dict:
-            mark_options = option_dict_to_str(mark_option_dict)
-            options_dict["mark options"] = f"{{{mark_options}}}"
-
-    elif mode == "lines":
-        options_dict["mark"] = "none"
-
-    elif "lines" in mode and "markers" in mode:
-        if marker.symbol is not None:
-            symbol, symbol_options = marker_symbol_to_tex(marker.symbol)
-            options_dict["mark"] = symbol
-            if symbol_options is not None:
-                mark_option_dict[symbol_options[0]] = symbol_options[1]
-
-    else:
-        warn(f"Scatter3d : Mode {mode} is not supported yet.")
+    finalize_marker_options(mode, options_dict, mark_option_dict, "Scatter3d")
 
     if scatter.line is not None:
         if scatter.line.width is not None:

tikzplotly/_trace_utils.py

@@ -0,0 +1,70 @@
+"""Shared helpers for Plotly trace to TikZ conversion."""
+
+from warnings import warn
+
+from ._color import convert_color
+from ._marker import marker_symbol_to_tex
+from ._utils import px_to_pt, option_dict_to_str
+
+
+def configure_marker_options(mode, marker, options_dict, mark_option_dict, color_set):
+    """Populate marker-related TikZ options for scatter-like traces.
+
+    Parameters
+    ----------
+    mode
+        Plotly trace mode string (for example ``markers`` or ``markers+lines``).
+    marker
+        Plotly marker object from the trace.
+    options_dict
+        Dictionary collecting top-level PGFPlots options.
+    mark_option_dict
+        Dictionary collecting nested ``mark options`` for PGFPlots.
+    color_set
+        Set used to track colors that must be defined in the LaTeX output.
+    """
+
+    if marker.symbol is not None:
+        symbol, symbol_options = marker_symbol_to_tex(marker.symbol)
+        options_dict["mark"] = symbol
+        if "lines" not in mode:
+            options_dict["only marks"] = None
+        if symbol_options is not None:
+            mark_option_dict[symbol_options[0]] = symbol_options[1]
+    elif "lines" not in mode:
+        options_dict["only marks"] = None
+
+    if (line := marker.line) is not None:
+        if line.color is not None:
+            color = convert_color(line.color)
+            color_set.add(color[:3])
+            mark_option_dict["draw"] = color[0]
+        if line.width is not None:
+            mark_option_dict["line width"] = px_to_pt(line.width)
+
+
+def finalize_marker_options(mode, options_dict, mark_option_dict, trace_name):
+    """Finalize marker options and handle unsupported modes.
+
+    Parameters
+    ----------
+    mode
+        Plotly trace mode string.
+    options_dict
+        Dictionary collecting top-level PGFPlots options.
+    mark_option_dict
+        Dictionary collecting nested ``mark options`` for PGFPlots.
+    trace_name
+        Name used in warnings to identify the trace kind.
+    """
+
+    if "markers" in mode:
+        if mark_option_dict:
+            mark_options = option_dict_to_str(mark_option_dict)
+            options_dict["mark options"] = f"{{{mark_options}}}"
+        return
+
+    if mode == "lines":
+        options_dict["mark"] = "none"
+    else:
+        warn(f"{trace_name} : Mode {mode} is not supported yet.")

tikzplotly/_utils.py

@@ -93,18 +93,10 @@ def sanitize_char(ch: str, keep_space: int = 0) -> str:
     if ch == "@":
         return "at"
     if ch == " ":
-        if keep_space == 1:
-            return " "
-        if keep_space == 0:
-            return "_"
-        return ""
+        return " " if keep_space == 1 else "_" if keep_space == 0 else ""
     if ch in "[]{}= ":
         return f"x{ord(ch):x}"
-    # if not ascii, return hex
-    if ord(ch) > 127:
-        return f"x{ord(ch):x}"
-    # if not printable, return hex
-    if not ch.isprintable():
+    if ord(ch) > 127 or not ch.isprintable():   # not ascii or not printable: return hex
         return f"x{ord(ch):x}"
     return ch
 

{tikzplotly-0.2.1.dist-info → tikzplotly-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplotly
-Version: 0.2.1
+Version: 0.2.3
 Summary: Convert plotly figures to LaTeX / TikZ figures
 Author-email: Thomas Saigre <tikzplotly@outlook.fr>
 License: The MIT License (MIT)
@@ -30,11 +30,11 @@ Keywords: plotly,latex,tikz,figure,conversion,graphics
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
@@ -44,6 +44,7 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: plotly
 Requires-Dist: pillow
+Requires-Dist: kaleido
 Provides-Extra: dev
 Requires-Dist: pandas; extra == "dev"
 Dynamic: license-file
@@ -65,7 +66,7 @@ Dynamic: license-file
 
 # Tikzplotly
 
-Convert [plotly](https://plotly.com/python/) figures to TikZ code for inclusion into [PGFPlots](https://www.ctan.org/pkg/pgfplots) ([PGF/TikZ](https://www.ctan.org/pkg/pgf)) figures.
+Convert [Plotly](https://plotly.com/python/) figures to TikZ code for inclusion into [PGFPlots](https://www.ctan.org/pkg/pgfplots) ([PGF/TikZ](https://www.ctan.org/pkg/pgf)) figures.
 
 This results in a ti*k*z code, that can be easily included into your LaTeX document.
 This also allows to easily edit the content of the figure.
@@ -151,9 +152,9 @@ To correctly compile the document, you will need to add the following packages t
 
 ## Note
 
-* This module is in development and new features are added bit by bit, when needed. If you have a feature request, please open an issue with the plotly figure you want to convert and the desired output.
+* This module is in development and new features are added bit by bit, when needed. If you have a feature request, please open an issue with the Plotly figure you want to convert and the desired output.
 You can also submit a pull request with the desired feature !
-* Some feature can result in different output between the plotly figure and the TikZ figure, for instance the size of markers, more details can be found in [the documentation](https://thomas-saigre.github.io/tikzplotly/).
+* Some feature can result in different output between the Plotly figure and the TikZ figure, for instance the size of markers, more details can be found in [the documentation](https://thomas-saigre.github.io/tikzplotly/).
 
 
 ## References

tikzplotly-0.2.3.dist-info/RECORD

@@ -0,0 +1,32 @@
+tests/test_bars.py,sha256=SGLDCNubaThFso47yad5w37AYrrVpoNK5fUkzuvAjtc,10122
+tests/test_heatmaps.py,sha256=CIPadAP56Bb3cRTAqngo0O2iZPR_RSSVeopQdrikz_A,6251
+tests/test_histograms.py,sha256=Ry4SsM4JBD5rXrvN6bxebNmLNK0mOZE5XIV9RXlQod4,8971
+tests/test_line_charts.py,sha256=cyiVuUyH1lZ51p_JVcP3xjLlEEbSm_iD5gj6F4p8DUo,15811
+tests/test_markers.py,sha256=g3ioyRqRh__VyKGET2RpCiEmLnQAztsYF5drqTq3idU,11555
+tests/test_polar.py,sha256=xvVx-Af855-eIw5Kmq1ApHHCv9hGr2WF6HuaN4XMZms,17244
+tests/test_scatter3d.py,sha256=yfieEogsVS2Wa5DgPJzIvsW2jz8yaPhkVU_nDrBWVTg,4359
+tikzplotly/__about__.py,sha256=sSgIKdBwORCAvELWyq6Xw2FHBdwRMjSmC4bbXwVFQtI,204
+tikzplotly/__init__.py,sha256=_0q4GULEJ5-HsYvckWpomrsdKck1Q7S92A4Ldxl3K9o,946
+tikzplotly/_annotations.py,sha256=r3MPz_Ocx3oQzsCuqKT3pdX1ijb3-LAmYHpLPLulASI,3108
+tikzplotly/_axis.py,sha256=t-v97WnUJMq3ulRi_1E9r0Sv3glodVtqmzIWUftwFlQ,8062
+tikzplotly/_bar.py,sha256=m4Hc4GR-bnEdrS3tU7VgZqCz0mdA9ENfBjGAvjavpA8,3263
+tikzplotly/_browser.py,sha256=GUYAXAhRGr693ouSYC6aAbodrTUhcON2W3vP9aWdwS0,15247
+tikzplotly/_color.py,sha256=hnBMZsVBs1M6YV1_hqquZYuLCO-fBEUaxtwD6cd-fMQ,41213
+tikzplotly/_dash.py,sha256=8hOaqzMDRcikD2HNWc18fzJm2Lvoq3eo3Tu8n0gAqvE,228
+tikzplotly/_data.py,sha256=t3TG0jvc_cjR84Ug04OUDyfF0hKFD_xKOgbgb1Xz-8M,1847
+tikzplotly/_data_container.py,sha256=VMOq6-UmjMDF_Aox_33HxdSrFFZKA_uHG55IoneprDY,8837
+tikzplotly/_heatmap.py,sha256=tUxs4gEaqi0TyY5TIInTJa_APUQPTnV0RXuDkWQ0N7w,5095
+tikzplotly/_histogram.py,sha256=PH0c1ZFU7VnJoWD6NIsF4VJAWReWZhGwNm1iZs7OXu0,5112
+tikzplotly/_marker.py,sha256=L5E_-fb4Fkv231dBmA72byAZeYPeVuKOFZIYTyLbMrs,11839
+tikzplotly/_polar.py,sha256=qhza1x53wgCjAafGIt1ncdRfKFLIlJJE5cvoR80TrIs,7792
+tikzplotly/_save.py,sha256=uqV0lCqf68_OyyfvzMBukf-JaPGG4UkFkFGVMjxnmLE,10343
+tikzplotly/_scatter.py,sha256=Eu9RhAUUZHH4q7l6NWayzVsJh33vPkCvWbCnR4vwUME,3538
+tikzplotly/_scatter3d.py,sha256=Fd3Rx0d8o-CefPSU8CyGD_BNJ7wB8yr_QbaKuWEG1qo,2389
+tikzplotly/_tex.py,sha256=LlsMRncCzmGJGO9OtgKyDMEnVA7WKvLptqh1yM5LdmQ,6555
+tikzplotly/_trace_utils.py,sha256=NyQYkxtrRLHuA9pjfNqUihW3rYvdwvDo8Kj9IEaJo5I,2316
+tikzplotly/_utils.py,sha256=vGvqlwKzv_R6euq1kGp5nmET9ACxy17P72Fv5cBx1Dc,6241
+tikzplotly-0.2.3.dist-info/licenses/LICENSE,sha256=cjxM8VJ_qnjUVKoOndGip4HgyyElZZI8Hk8g3rXEFf8,1080
+tikzplotly-0.2.3.dist-info/METADATA,sha256=kpfNghHJJP-cNXrXbAUlxpqWCwKJKGBjtQMu8XxeD7Q,6644
+tikzplotly-0.2.3.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+tikzplotly-0.2.3.dist-info/top_level.txt,sha256=NSVJ1u8Bv6DVRb_y_Roui9D7tVh2XYDaGVjSbZyTrH4,17
+tikzplotly-0.2.3.dist-info/RECORD,,

{tikzplotly-0.2.1.dist-info → tikzplotly-0.2.3.dist-info}/WHEEL

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

tikzplotly-0.2.1.dist-info/RECORD

@@ -1,30 +0,0 @@
-tests/test_bars.py,sha256=SGLDCNubaThFso47yad5w37AYrrVpoNK5fUkzuvAjtc,10122
-tests/test_heatmaps.py,sha256=CIPadAP56Bb3cRTAqngo0O2iZPR_RSSVeopQdrikz_A,6251
-tests/test_histograms.py,sha256=Ry4SsM4JBD5rXrvN6bxebNmLNK0mOZE5XIV9RXlQod4,8971
-tests/test_line_charts.py,sha256=cyiVuUyH1lZ51p_JVcP3xjLlEEbSm_iD5gj6F4p8DUo,15811
-tests/test_markers.py,sha256=g3ioyRqRh__VyKGET2RpCiEmLnQAztsYF5drqTq3idU,11555
-tests/test_polar.py,sha256=xvVx-Af855-eIw5Kmq1ApHHCv9hGr2WF6HuaN4XMZms,17244
-tests/test_scatter3d.py,sha256=yfieEogsVS2Wa5DgPJzIvsW2jz8yaPhkVU_nDrBWVTg,4359
-tikzplotly/__about__.py,sha256=FzUiA25vg6WQJ-ceAlEl9VIpIjolTD0pIM618yZkIV8,204
-tikzplotly/__init__.py,sha256=PrbDMOviELxIm9nyXS6Qk56-YhuTb-bAn_0BuY2rHLE,552
-tikzplotly/_annotations.py,sha256=r3MPz_Ocx3oQzsCuqKT3pdX1ijb3-LAmYHpLPLulASI,3108
-tikzplotly/_axis.py,sha256=t-v97WnUJMq3ulRi_1E9r0Sv3glodVtqmzIWUftwFlQ,8062
-tikzplotly/_bar.py,sha256=m4Hc4GR-bnEdrS3tU7VgZqCz0mdA9ENfBjGAvjavpA8,3263
-tikzplotly/_color.py,sha256=5qhBog-KjoS_inliITOkuiIfC09FaXZWJ2vUZy0UWpU,41098
-tikzplotly/_dash.py,sha256=8hOaqzMDRcikD2HNWc18fzJm2Lvoq3eo3Tu8n0gAqvE,228
-tikzplotly/_data.py,sha256=t3TG0jvc_cjR84Ug04OUDyfF0hKFD_xKOgbgb1Xz-8M,1847
-tikzplotly/_dataContainer.py,sha256=6TISCqi-EUmZ_PlzDo2IxxHakddp2UPrA7uwIMpjRiE,7057
-tikzplotly/_heatmap.py,sha256=Pd_08D8Yt6TH-NsenSws6MnTmbxtvr17dY5s-6PE05Q,5023
-tikzplotly/_histogram.py,sha256=INS965-KmYYbFuG0fTOSXesmKduv4l3tz9hlbmU2xZE,5520
-tikzplotly/_marker.py,sha256=L5E_-fb4Fkv231dBmA72byAZeYPeVuKOFZIYTyLbMrs,11839
-tikzplotly/_polar.py,sha256=tXrZQqpCdWz15kYkKBI2CMwTyYvotlHhyObkaa4asMc,7791
-tikzplotly/_save.py,sha256=S4MeaaTcPRXMSmDpHMUXUoqathkhy-wDUORdpzS7NHQ,10216
-tikzplotly/_scatter.py,sha256=soPBLJqvy9vUUwwFPhrtJbpFFWtHehEJZ-ec4-LXJAw,4681
-tikzplotly/_scatter3d.py,sha256=49EzI-0IuQU8AcQua7N3Y87U1N6bp1qe_PpFgGEIEXc,3545
-tikzplotly/_tex.py,sha256=LlsMRncCzmGJGO9OtgKyDMEnVA7WKvLptqh1yM5LdmQ,6555
-tikzplotly/_utils.py,sha256=MykikiJzMmVFUIBsnesLj2OzIyoUwDgKTSqs8zkTv6o,6346
-tikzplotly-0.2.1.dist-info/licenses/LICENSE,sha256=cjxM8VJ_qnjUVKoOndGip4HgyyElZZI8Hk8g3rXEFf8,1080
-tikzplotly-0.2.1.dist-info/METADATA,sha256=DRQTfURJS7wCFhH6lAZuLH5FPkfbv_bGw4TB4SEbg0Q,6620
-tikzplotly-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tikzplotly-0.2.1.dist-info/top_level.txt,sha256=NSVJ1u8Bv6DVRb_y_Roui9D7tVh2XYDaGVjSbZyTrH4,17
-tikzplotly-0.2.1.dist-info/RECORD,,