tikzplotly 0.2.2__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.2"
+__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/_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,16 +184,21 @@ 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
 
@@ -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/_save.py

@@ -25,10 +25,11 @@ 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,7 +75,7 @@ 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):
@@ -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 = 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-0.2.2.dist-info → tikzplotly-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplotly
-Version: 0.2.2
+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
@@ -66,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.
@@ -152,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.2.dist-info → tikzplotly-0.2.3.dist-info}/RECORD

@@ -5,27 +5,28 @@ tests/test_line_charts.py,sha256=cyiVuUyH1lZ51p_JVcP3xjLlEEbSm_iD5gj6F4p8DUo,158
 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=W0m95bZPSmPKyrbh5zZGO071YHBbLsK0LQxvES50b7c,204
-tikzplotly/__init__.py,sha256=PrbDMOviELxIm9nyXS6Qk56-YhuTb-bAn_0BuY2rHLE,552
+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=G2mE8tgRfZV4pzNGWa23JCo4e63j_Rpm0wszXlunvAU,7040
+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=YuR0gqVtK6EhCyYoMxbVEHvzCMofEILV-42Ulp8iHU4,10219
+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.2.dist-info/licenses/LICENSE,sha256=cjxM8VJ_qnjUVKoOndGip4HgyyElZZI8Hk8g3rXEFf8,1080
-tikzplotly-0.2.2.dist-info/METADATA,sha256=YX9jbyjsA7-d1rGp5_Kil0v4O7-r9X7syJqgvINqQ0M,6643
-tikzplotly-0.2.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-tikzplotly-0.2.2.dist-info/top_level.txt,sha256=NSVJ1u8Bv6DVRb_y_Roui9D7tVh2XYDaGVjSbZyTrH4,17
-tikzplotly-0.2.2.dist-info/RECORD,,
+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.2.dist-info → tikzplotly-0.2.3.dist-info}/WHEEL

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