tikzplotly 0.2.2__tar.gz → 0.2.3__tar.gz

{tikzplotly-0.2.2/src/tikzplotly.egg-info → tikzplotly-0.2.3}/PKG-INFO

@@ -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 → tikzplotly-0.2.3}/README.md

@@ -15,7 +15,7 @@
 
 # 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.
@@ -101,9 +101,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 → tikzplotly-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tikzplotly"
-version = "0.2.2"
+version = "0.2.3"
 description = "Convert plotly figures to LaTeX / TikZ figures"
 readme = "README.md"
 authors = [{name = "Thomas Saigre", email = "tikzplotly@outlook.fr"}]
@@ -13,11 +13,11 @@ classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Topic :: Multimedia :: Graphics :: Graphics Conversion",

{tikzplotly-0.2.2 → tikzplotly-0.2.3}/src/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-0.2.2 → tikzplotly-0.2.3}/src/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-0.2.3/src/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-0.2.2 → tikzplotly-0.2.3}/src/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-0.2.2 → tikzplotly-0.2.3}/src/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 → tikzplotly-0.2.3/src/tikzplotly.egg-info}/PKG-INFO

@@ -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 → tikzplotly-0.2.3}/src/tikzplotly.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/tikzplotly/__init__.py
 src/tikzplotly/_annotations.py
 src/tikzplotly/_axis.py
 src/tikzplotly/_bar.py
+src/tikzplotly/_browser.py
 src/tikzplotly/_color.py
 src/tikzplotly/_dash.py
 src/tikzplotly/_data.py
@@ -33,6 +34,7 @@ src/tikzplotly.egg-info/dependency_links.txt
 src/tikzplotly.egg-info/requires.txt
 src/tikzplotly.egg-info/top_level.txt
 tests/test_bars.py
+tests/test_browser.py
 tests/test_colors.py
 tests/test_heatmap.py
 tests/test_histograms.py

tikzplotly-0.2.3/tests/test_browser.py

@@ -0,0 +1,157 @@
+"""Tests of the "Export to TikZ" button: the local server is exercised directly, without a browser."""
+import http.client
+import io
+import json
+import re
+
+import numpy as np
+import plotly.graph_objects as go
+import plotly.io as pio
+import pytest
+from PIL import Image
+
+import tikzplotly
+from tikzplotly import _browser
+
+
+@pytest.fixture(name="short_timeouts")
+def fixture_short_timeouts(monkeypatch):
+    monkeypatch.setattr(_browser, "IDLE_TIMEOUT", 10)
+    monkeypatch.setattr(_browser, "CLOSE_GRACE", 0)
+
+
+def make_figure():
+    x = np.linspace(0, 10, 11)
+    fig = go.Figure([go.Scatter(x=x, y=x**2, name="a"), go.Scatter(x=x, y=x, name="b")])
+    fig.update_layout(title="demo")
+    return fig
+
+
+class Page:
+    """Plays the part of the browser page."""
+
+    def __init__(self, url):
+        self.port = int(url.rstrip("/").rsplit(":", 1)[1])
+        status, html = self.request("GET", "/")
+        assert status == 200
+        self.html = html.decode("utf-8")
+        token_match = re.search(r"var token = '([^']+)'", self.html)
+        assert token_match is not None
+        self.token = token_match.group(1)
+
+    def request(self, method, path, body=None, host=None):
+        conn = http.client.HTTPConnection("127.0.0.1", self.port, timeout=10)
+        headers = {"Host": host or f"127.0.0.1:{self.port}"}
+        conn.request(method, path, json.dumps(body or {}) if method == "POST" else None, headers)
+        response = conn.getresponse()
+        return response.status, response.read()
+
+    def post(self, action, body=None, token=None):
+        status, raw = self.request("POST", f"/{token or self.token}/{action}", body)
+        return status, json.loads(raw)
+
+    def close(self, thread):
+        self.post("closing")
+        thread.join(timeout=10)
+        assert not thread.is_alive()
+
+
+def test_renderer_registered():
+    assert isinstance(pio.renderers["tikzplotly"], tikzplotly.TikzBrowserRenderer)
+
+
+def test_export_button(tmp_path, short_timeouts):  # pylint: disable=unused-argument
+    renderer = tikzplotly.TikzBrowserRenderer(tmp_path / "out" / "fig.tex", axis_options="width=8cm")
+    url, thread = renderer.start_server(make_figure())
+    page = Page(url)
+    assert "exportTikz" in page.html
+
+    status, result = page.post("export", {"axes": {"xaxis": None, "yaxis": None}, "visible": [None, None]})
+    assert status == 200 and result["ok"]
+    first = (tmp_path / "out" / "fig.tex").read_text(encoding="utf-8")
+    assert "width=8cm" in first and "\\addlegendentry{b}" in first and "xmin" not in first
+
+    # Zoomed in, second trace hidden from the legend: a new file, reflecting the view.
+    _, result = page.post("export", {"axes": {"xaxis": [2, 5], "yaxis": [0, 30]}, "visible": [True, "legendonly"]})
+    assert result["path"] == str(tmp_path / "out" / "fig_1.tex")
+    second = (tmp_path / "out" / "fig_1.tex").read_text(encoding="utf-8")
+    assert "xmin=2" in second and "ymax=30" in second
+    assert "\\addlegendentry{a}" in second and "\\addlegendentry{b}" not in second
+
+    page.close(thread)
+
+
+def test_requests_rejected(tmp_path, short_timeouts):  # pylint: disable=unused-argument
+    renderer = tikzplotly.TikzBrowserRenderer(tmp_path / "fig.tex")
+    url, thread = renderer.start_server(make_figure())
+    page = Page(url)
+    assert page.post("export", token="wrong")[0] == 403
+    assert page.request("POST", "/export")[0] == 403
+    assert page.request("GET", "/", host="evil.example:80")[0] == 403
+    assert page.post("unknown")[0] == 404
+    assert not list(tmp_path.iterdir())
+    page.close(thread)
+
+
+def test_export_error_reported(tmp_path, short_timeouts):  # pylint: disable=unused-argument
+    blocker = tmp_path / "blocker"
+    blocker.write_text("", encoding="utf-8")  # a file where a directory is needed
+    renderer = tikzplotly.TikzBrowserRenderer(blocker / "fig.tex")
+    url, thread = renderer.start_server(make_figure())
+    page = Page(url)
+    status, result = page.post("export")
+    assert status == 200 and not result["ok"] and result["error"]
+    page.close(thread)
+
+
+def test_idle_timeout(monkeypatch, tmp_path):
+    monkeypatch.setattr(_browser, "IDLE_TIMEOUT", 0.5)
+    _, thread = tikzplotly.TikzBrowserRenderer(tmp_path / "fig.tex").start_server(make_figure())
+    thread.join(timeout=10)
+    assert not thread.is_alive()
+
+
+def test_figure_dict_with_binary_arrays(tmp_path):
+    """Renderers receive ``fig.to_dict()``, where NumPy arrays are base64-encoded since Plotly 6."""
+    renderer = tikzplotly.TikzBrowserRenderer(tmp_path / "fig.tex")
+    path = renderer.export(make_figure().to_dict())
+    assert path.read_text(encoding="utf-8") == tikzplotly.get_tikz_code(make_figure(), img_name=str(tmp_path / "fig.png"))
+
+
+def fake_png(*args, **kwargs):  # pylint: disable=unused-argument
+    """Stands for ``Figure.to_image``: a coloured block on a white background, like a heatmap."""
+    image = Image.new("RGBA", (60, 40), "white")  # kaleido makes RGBA images
+    image.paste((68, 1, 84, 255), (10, 10, 40, 30))
+    buffer = io.BytesIO()
+    image.save(buffer, format="png")
+    return buffer.getvalue()
+
+
+def test_heatmap_image_next_to_tex(tmp_path, monkeypatch):
+    # The image itself is tested in test_heatmap.py: kaleido is not needed to check file names.
+    monkeypatch.setattr(go.Figure, "to_image", fake_png)
+    renderer = tikzplotly.TikzBrowserRenderer(tmp_path / "map.tex")
+    fig = go.Figure(go.Heatmap(z=np.arange(6.0).reshape(2, 3), colorscale="Viridis"))
+    renderer.export(fig.to_dict())
+    renderer.export(fig.to_dict())
+    assert sorted(p.name for p in tmp_path.iterdir()) == ["map.png", "map.tex", "map_1.png", "map_1.tex"]
+
+
+def test_show_opens_browser(monkeypatch, tmp_path, short_timeouts):  # pylint: disable=unused-argument
+    opened = []
+    monkeypatch.setattr(_browser.webbrowser, "open", opened.append)
+    started = []
+    original = _browser.TikzBrowserRenderer.start_server
+
+    def start_server(self, fig):
+        started.append(original(self, fig))
+        return started[-1]
+
+    monkeypatch.setattr(_browser.TikzBrowserRenderer, "start_server", start_server)
+
+    fig = make_figure()
+    tikzplotly.show(fig, tmp_path / "fig.tex")
+    fig.show(renderer="tikzplotly")
+    assert opened == [url for url, _ in started] and len(opened) == 2
+    for url, thread in started:
+        Page(url).close(thread)

{tikzplotly-0.2.2 → tikzplotly-0.2.3}/tests/test_heatmap.py

@@ -7,6 +7,9 @@ from .helpers import assert_equality
 import pathlib
 import datetime
 
+import sys
+pytestmark = pytest.mark.skipif(sys.platform == "darwin", reason="kaleido is unreliable on macOS runners")
+
 this_dir = pathlib.Path(__file__).resolve().parent
 test_name = "test_heatmap"
 pathlib.Path("/tmp/tikzplotly").mkdir(parents=True, exist_ok=True)

{tikzplotly-0.2.2 → tikzplotly-0.2.3}/tests/test_polar.py

@@ -6,8 +6,12 @@ import plotly.express as px
 import plotly.graph_objects as go
 import pandas as pd
 import pytest
+import warnings
+from urllib.error import URLError
 from .helpers import assert_equality
 
+from warnings import warn
+
 this_dir = pathlib.Path(__file__).resolve().parent
 test_name = "test_polar"
 
@@ -252,7 +256,13 @@ def test_radar_1():
     assert_equality(plot_radar_1(), os.path.join(this_dir, test_name, test_name + "_radar_1_reference.tex"))
 
 def test_radar_2():
-    assert_equality(plot_radar_2(), os.path.join(this_dir, test_name, test_name + "_radar_2_reference.tex"))
+    try:
+        fig = plot_radar_2()
+        assert_equality(fig, os.path.join(this_dir, test_name, test_name + "_radar_2_reference.tex"))
+    except URLError as e:
+        warnings.warn(f"Offline: {e}. Skipping test_radar_2.", UserWarning)
+        pytest.skip("Offline: Could not fetch data for radar plot.")
+
 
 def test_polar_categorial_angular():
     assert_equality(fig_polar_categorial_angular(), os.path.join(this_dir, test_name, test_name + "_categorical_angular_reference.tex"))
@@ -273,6 +283,12 @@ def test_polar_range_2():
     assert_equality(fig_polar_range_2(), os.path.join(this_dir, test_name, test_name + "_radar_range_2_reference.tex"))
 
 def test_polar_1():
+    try:
+        fig = fig_polar_1()
+        assert_equality(fig, os.path.join(this_dir, test_name, test_name + "_1_reference.tex"))
+    except URLError as e:
+        warnings.warn(f"Offline: {e}. Skipping test_polar_1.", UserWarning)
+        pytest.skip("Offline: Could not fetch data for radar plot.")
     assert_equality(fig_polar_1(), os.path.join(this_dir, test_name, test_name + "_1_reference.tex"))
 
 def test_polar_matplotlib():

{tikzplotly-0.2.2 → tikzplotly-0.2.3}/tests/test_scatter.py

@@ -211,6 +211,11 @@ def plot_10():
     fig.update_yaxes(autorange="reversed")
     return fig
 
+def plot_decimate():
+    x = np.linspace(-6, 6, 103)
+    y = np.sin(x)
+    fig = px.scatter(x=x, y=y)
+    return fig
 
 def test_1():
     assert_equality(plot_1(), os.path.join(this_dir, test_name, test_name + "_1_reference.tex"))
@@ -249,3 +254,17 @@ def test_9():
 
 def test_10():
     assert_equality(plot_10(), os.path.join(this_dir, test_name, test_name + "_10_reference.tex"))
+
+@pytest.mark.parametrize("d", [10, 1, None])
+def test_decimate(d):
+    if not d:
+        d_path = 1
+    else:
+        d_path = d
+    assert_equality(plot_decimate(), os.path.join(this_dir, test_name, test_name + f"_decimate_{d_path}_reference.tex"), decimate=d)
+
+def test_failing_decimate():
+    try:
+        assert_equality(plot_decimate(), os.path.join(this_dir, test_name, test_name + f"_decimate_1_reference.tex"), decimate=-1)
+    except ValueError as e:
+        assert e.__str__() == "decimate must be None or an integer >= 1"

{tikzplotly-0.2.2 → tikzplotly-0.2.3}/tests/test_scatter3d.py

@@ -76,7 +76,6 @@ def plot_scatter_3d_view():
     )
     return fig
 
-
 def plot_scatter_3d_empty():
     return go.Figure(data=[go.Scatter3d(
         x=None,
@@ -84,6 +83,7 @@ def plot_scatter_3d_empty():
         z=None,
     )])
 
+
 def test_scatter_3d_1():
     assert_equality(plot_scatter_3d_1(), os.path.join(this_dir, test_name, test_name + "_1_reference.tex"))
 
@@ -106,3 +106,16 @@ def test_scatter_3d_view():
 def test_scatter_3d_empty():
     with pytest.warns(UserWarning, match="Adding empty 3D trace."):
         assert_equality(plot_scatter_3d_empty(), os.path.join(this_dir, test_name, test_name + "_empty_reference.tex"))
+
+@pytest.mark.parametrize("d", [6, 1, None])
+def test_failing_decimate(d):
+    suffix = "6_" if d == 6 else ""
+    assert_equality(plot_scatter_3d_3(), os.path.join(this_dir, test_name, test_name + f"_3_{suffix}reference.tex"), decimate=d)
+
+def test_scatter_3d_decimate():
+    try:
+        assert_equality(plot_scatter_3d_3(), os.path.join(this_dir, test_name, test_name + f"_3_reference.tex"), decimate=-1)
+    except ValueError as e:
+        assert e.__str__() == "decimate must be None or an integer >= 1"
+
+