babelplot 2025.6__tar.gz → 2025.7__tar.gz

{babelplot-2025.6 → babelplot-2025.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: babelplot
-Version: 2025.6
+Version: 2025.7
 Summary: A Meta Plotting Library That Speaks Several Backends
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/babelplot/
 Author: Eric Debreuve

{babelplot-2025.6 → babelplot-2025.7}/package/babelplot/backend/catalog/bokeh_.py

@@ -7,7 +7,7 @@ SEE COPYRIGHT NOTICE BELOW
 import dataclasses as d
 import typing as h
 
-from babelplot.task.showing import Show
+from babelplot.task.showing import ShowHTMLWithPyQt
 from babelplot.type.dimension import dim_e
 from babelplot.type.figure import figure_t as base_figure_t
 from babelplot.type.frame import frame_t as base_frame_t
@@ -59,8 +59,11 @@ class frame_t(base_frame_t):
 class figure_t(base_figure_t):
     layout: h.Any = None
 
-    _NewBackendFigure = backend_figure_t
-    _BackendShow = Show
+    _BackendShow = ShowHTMLWithPyQt
+
+    def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_t:
+        """"""
+        return backend_figure_t(*args, **kwargs)
 
     def _NewFrame(
         self,

{babelplot-2025.6 → babelplot-2025.7}/package/babelplot/backend/catalog/matplotlib_.py

@@ -124,10 +124,13 @@ class figure_t(base_figure_t):
     _BackendSetProperty: h.ClassVar[h.Callable] = _SetProperty
     _BackendProperty: h.ClassVar[h.Callable] = _Property
 
-    @staticmethod
-    def _NewBackendFigure(*args, **kwargs) -> backend_figure_t:
+    def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_t:
         """"""
-        return NewBackendFigure(*args, num=None, **kwargs)
+        output = NewBackendFigure(*args, num=None, **kwargs)
+
+        output.canvas.mpl_connect("close_event", lambda *_, **__: _OnCloseEvent(self))
+
+        return output
 
     def _NewFrame(
         self,
@@ -199,27 +202,27 @@ class figure_t(base_figure_t):
             )
             frame.raw.set_position((left, bottom, width, height))
 
-    def _BackendShow(self) -> None:
+    def _BackendShow(self, modal: bool, /) -> None:
         """"""
         raw = self.raw
-
         raw.show()
 
-        event_manager = raw.canvas
-        event_manager.mpl_connect(
-            "close_event", lambda _: event_manager.stop_event_loop()
-        )
-        event_manager.start_event_loop()
+        if modal:
+            title = raw.get_suptitle()
+            if title.__len__() > 0:
+                title = f"{title} [MASTER FIGURE]"
+            else:
+                title = "MASTER FIGURE"
+            raw.suptitle(title)
 
+            raw.canvas.start_event_loop()
 
-def _Polygon(
-    frame: backend_frame_2d_t, xs: array_t, ys: array_t, *_, **kwargs
-) -> polygon_t:
-    """"""
-    output = polygon_t(nmpy.vstack((xs, ys)).T, **kwargs)
-    frame.add_patch(output)
 
-    return output
+def _OnCloseEvent(figure: figure_t, /) -> None:
+    """"""
+    # Hopefully, the event loop does not mind being stopped several times.
+    figure.raw.canvas.stop_event_loop()
+    figure.AcknowledgeClosure()
 
 
 def _Arrows2(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
@@ -268,6 +271,54 @@ def _Arrows3(frame: backend_frame_3d_t, *args, **kwargs) -> backend_plot_t:
     return frame.quiver(x, y, z, u, v, w, **kwargs)
 
 
+def _Bar3(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
+    """"""
+    if args.__len__() == 1:
+        counts = nmpy.asarray(args[0])
+        x, y = counts.shape
+    else:
+        x, y, counts = args
+        counts = nmpy.asarray(counts)
+    if isinstance(x, int):
+        x, y = nmpy.meshgrid(range(x), range(y), indexing="ij")
+    if counts.ndim == 1:
+        x = x.ravel()
+        y = y.ravel()
+
+    width = kwargs.get("width", 0.8)
+    depth = kwargs.get("depth", 0.8)
+    offset = kwargs.get("offset", 0.0)
+    kwargs = {
+        _key: _vle
+        for _key, _vle in kwargs.items()
+        if _key not in ("width", "depth", "offset")
+    }
+
+    return frame.bar3d(x, y, offset, width, depth, counts, **kwargs)
+
+
+def _BarH(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plots_t:
+    """"""
+    if args.__len__() == 1:
+        counts = args[0]
+        positions = range(counts.__len__())
+    else:
+        positions, counts = args
+
+    return frame.barh(positions, counts, **kwargs)
+
+
+def _BarV(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plots_t:
+    """"""
+    if args.__len__() == 1:
+        counts = args[0]
+        positions = range(counts.__len__())
+    else:
+        positions, counts = args
+
+    return frame.bar(positions, counts, **kwargs)
+
+
 def _ElevationSurface(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
     """"""
     if args.__len__() == 1:
@@ -319,52 +370,14 @@ def _Mesh(
     )
 
 
-def _BarH(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plots_t:
-    """"""
-    if args.__len__() == 1:
-        counts = args[0]
-        positions = range(counts.__len__())
-    else:
-        positions, counts = args
-
-    return frame.barh(positions, counts, **kwargs)
-
-
-def _BarV(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plots_t:
-    """"""
-    if args.__len__() == 1:
-        counts = args[0]
-        positions = range(counts.__len__())
-    else:
-        positions, counts = args
-
-    return frame.bar(positions, counts, **kwargs)
-
-
-def _Bar3(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
+def _Polygon(
+    frame: backend_frame_2d_t, xs: array_t, ys: array_t, *_, **kwargs
+) -> polygon_t:
     """"""
-    if args.__len__() == 1:
-        counts = nmpy.asarray(args[0])
-        x, y = counts.shape
-    else:
-        x, y, counts = args
-        counts = nmpy.asarray(counts)
-    if isinstance(x, int):
-        x, y = nmpy.meshgrid(range(x), range(y), indexing="ij")
-    if counts.ndim == 1:
-        x = x.ravel()
-        y = y.ravel()
-
-    width = kwargs.get("width", 0.8)
-    depth = kwargs.get("depth", 0.8)
-    offset = kwargs.get("offset", 0.0)
-    kwargs = {
-        _key: _vle
-        for _key, _vle in kwargs.items()
-        if _key not in ("width", "depth", "offset")
-    }
+    output = polygon_t(nmpy.vstack((xs, ys)).T, **kwargs)
+    frame.add_patch(output)
 
-    return frame.bar3d(x, y, offset, width, depth, counts, **kwargs)
+    return output
 
 
 def _Text2(frame: backend_frame_2d_t, text, x, y, *_, **kwargs) -> backend_plot_t:
@@ -379,24 +392,23 @@ def _Text3(frame: backend_frame_2d_t, text, x, y, z, *_, **kwargs) -> backend_pl
 
 PLOTS = plot_e.NewPlotsTemplate()
 
-PLOTS[plot_e.SCATTER][1] = backend_frame_2d_t.scatter
-PLOTS[plot_e.POLYLINE][1] = backend_frame_2d_t.plot
-PLOTS[plot_e.POLYGON][1] = _Polygon
 PLOTS[plot_e.ARROWS][1] = _Arrows2
-PLOTS[plot_e.ISOSET][1] = _IsoContour
+PLOTS[plot_e.ARROWS][2] = _Arrows3
+PLOTS[plot_e.BAR3][2] = _Bar3
 PLOTS[plot_e.BARH][1] = _BarH
 PLOTS[plot_e.BARV][1] = _BarV
-PLOTS[plot_e.PIE][1] = backend_frame_2d_t.pie
-PLOTS[plot_e.IMAGE][1] = backend_frame_2d_t.matshow
-PLOTS[plot_e.TEXT][1] = _Text2
-
-PLOTS[plot_e.SCATTER][2] = backend_frame_3d_t.scatter
-PLOTS[plot_e.POLYLINE][2] = backend_frame_3d_t.plot
-PLOTS[plot_e.ARROWS][2] = _Arrows3
 PLOTS[plot_e.ELEVATION][2] = _ElevationSurface
+PLOTS[plot_e.IMAGE][1] = backend_frame_2d_t.matshow
+PLOTS[plot_e.ISOSET][1] = _IsoContour
 PLOTS[plot_e.ISOSET][2] = _IsoSurface
 PLOTS[plot_e.MESH][2] = _Mesh
-PLOTS[plot_e.BAR3][2] = _Bar3
+PLOTS[plot_e.PIE][1] = backend_frame_2d_t.pie
+PLOTS[plot_e.POLYGON][1] = _Polygon
+PLOTS[plot_e.POLYLINE][1] = backend_frame_2d_t.plot
+PLOTS[plot_e.POLYLINE][2] = backend_frame_3d_t.plot
+PLOTS[plot_e.SCATTER][1] = backend_frame_2d_t.scatter
+PLOTS[plot_e.SCATTER][2] = backend_frame_3d_t.scatter
+PLOTS[plot_e.TEXT][1] = _Text2
 PLOTS[plot_e.TEXT][2] = _Text3
 
 
@@ -407,7 +419,9 @@ TRANSLATIONS = {
     "color_max": "vmax",
     "color_min": "vmin",
     "color_scaling": "norm",
+    "colormap": "cmap",
     "depth_shade": "depthshade",
+    "opacity": "alpha",
     "plot_non_finite": "plotnonfinite",
     "size": "s",
     "width_edge": "linewidths",

{babelplot-2025.6 → babelplot-2025.7}/package/babelplot/backend/catalog/plotly_.py

@@ -5,12 +5,15 @@ SEE COPYRIGHT NOTICE BELOW
 """
 
 import dataclasses as d
+import gzip
+import typing as h
+from multiprocessing import Process as process_t
 from pathlib import Path as path_t
 
 import numpy as nmpy
 import plotly.figure_factory as fcry  # noqa
 import plotly.graph_objects as plly  # noqa
-from babelplot.task.showing import Show
+from babelplot.task.showing import ShowHTMLWithPyQt
 from babelplot.type.dimension import dim_e
 from babelplot.type.figure import figure_t as base_figure_t
 from babelplot.type.frame import frame_t as base_frame_t
@@ -64,8 +67,10 @@ class frame_t(base_frame_t):
 
 @d.dataclass(slots=True, repr=False, eq=False)
 class figure_t(base_figure_t):
-    _NewBackendFigure = backend_figure_t
-    _BackendShow = Show
+
+    def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_t:
+        """"""
+        return backend_figure_t(*args, **kwargs)
 
     def _NewFrame(
         self,
@@ -128,7 +133,7 @@ class figure_t(base_figure_t):
         if self.title is not None:
             raw.update_layout(title_text=self.title + title_postfix)
 
-    def AsHTML(self) -> str:
+    def _BackendShow(self, modal: bool, /) -> None:
         """
         Note on include_plotlyjs:
             - "cdn": works but must be online.
@@ -136,35 +141,16 @@ class figure_t(base_figure_t):
               PySide6.QtWebEngineWidgets.QWebEngineView.setHtml because of html size limit.
                 See note in babelplot.task.html.Show.
         """
-        return self.raw.to_html(include_plotlyjs=True, config=_FIGURE_CONFIG)
-
-
-def _Scatter2(x: array_t, y: array_t, *_, **kwargs) -> backend_plot_t:
-    """"""
-    return plly.Scatter(x=x, y=y, mode="markers", **kwargs)
-
-
-def _Scatter3(x: array_t, y: array_t, z: array_t, *_, **kwargs) -> backend_plot_t:
-    """"""
-    return plly.Scatter3d(x=x, y=y, z=z, mode="markers", **kwargs)
-
-
-def _Polyline2(x: array_t, y: array_t, *_, **kwargs) -> backend_plot_t:
-    """"""
-    return plly.Scatter(x=x, y=y, mode="lines", **kwargs)
-
-
-def _Polyline3(x: array_t, y: array_t, z: array_t, *_, **kwargs) -> backend_plot_t:
-    """"""
-    return plly.Scatter3d(x=x, y=y, z=z, mode="lines", **kwargs)
-
-
-def _Polygon(x: array_t, y: array_t, *_, **kwargs) -> backend_plot_t:
-    """"""
-    x = nmpy.concatenate((x, [x[0]]))
-    y = nmpy.concatenate((y, [y[0]]))
-
-    return plly.Scatter(x=x, y=y, mode="lines", fill="toself", **kwargs)
+        html = self.raw.to_html(include_plotlyjs=True, config=_FIGURE_CONFIG)
+        uid = id(self)
+        if modal:
+            ShowHTMLWithPyQt(html, uid)
+            self.AcknowledgeClosure()
+        else:
+            html = gzip.compress(html.encode())
+            process = process_t(target=lambda: ShowHTMLWithPyQt(html, uid))
+            process.start()
+            self.showing_process = process
 
 
 def _Arrows2(*args, **kwargs) -> backend_plot_t:
@@ -205,105 +191,6 @@ def _Arrows3(*args, **kwargs) -> backend_plot_t:
     )
 
 
-def _ElevationSurface(*args, **kwargs) -> backend_plot_t:
-    """"""
-    if args.__len__() == 1:
-        elevation = args[0]
-        x, y = nmpy.meshgrid(
-            range(elevation.shape[0]), range(elevation.shape[1]), indexing="ij"
-        )
-    else:
-        x, y, elevation = args
-
-    return plly.Surface(contours={}, x=x, y=y, z=elevation, **kwargs)
-
-
-def _IsoContour(*args, **kwargs) -> backend_plot_t:
-    """"""
-    parameters = {
-        "contours_coloring": "lines",
-        "line_width": 2,
-    }
-
-    if args.__len__() == 2:
-        values, value = args
-    else:
-        x, y, values, value = args
-        parameters["x"] = x
-        parameters["y"] = y
-    parameters["z"] = values
-    parameters["contours"] = {
-        "start": value,
-        "end": value,
-        "size": 1,
-        "showlabels": True,
-    }
-
-    parameters.update(kwargs)
-
-    return plly.Contour(**parameters)
-
-
-def _IsoSurface(values: array_t, value: float, *args, **kwargs) -> backend_plot_t:
-    """"""
-    if args.__len__() == 3:
-        x, y, z = args
-    else:
-        x, y, z = nmpy.meshgrid(
-            range(values.shape[0]),
-            range(values.shape[1]),
-            range(values.shape[2]),
-            indexing="ij",
-        )
-
-    parameters = {
-        "surface": {"count": 1},
-        "caps": {"x_show": False, "y_show": False, "z_show": False},
-    }
-    parameters.update(kwargs)
-
-    return plly.Isosurface(
-        x=x.ravel(),
-        y=y.ravel(),
-        z=z.ravel(),
-        value=values.ravel(),
-        isomin=value,
-        isomax=value,
-        **parameters,
-    )
-
-
-def _Mesh(triangles: array_t, vertices: array_t, *_, **kwargs) -> backend_plot_t:
-    """"""
-    return plly.Mesh3d(
-        x=vertices[:, 0],
-        y=vertices[:, 1],
-        z=vertices[:, 2],
-        i=triangles[:, 0],
-        j=triangles[:, 1],
-        k=triangles[:, 2],
-        **kwargs,
-    )
-
-
-def _BarH(*args, **kwargs) -> backend_plot_t:
-    """"""
-    return _BarV(*args, orientation="h", **kwargs)
-
-
-def _BarV(*args, **kwargs) -> backend_plot_t:
-    """"""
-    if args.__len__() == 1:
-        counts = args[0]
-        positions = tuple(range(counts.__len__()))
-    else:
-        positions, counts = args
-    if kwargs.get("orientation") == "h":
-        positions, counts = counts, positions
-
-    return plly.Bar(x=positions, y=counts, **kwargs)
-
-
 def _Bar3(*args, **kwargs) -> backend_plot_t:
     """"""
     if args.__len__() == 1:
@@ -406,9 +293,35 @@ def _Bar3(*args, **kwargs) -> backend_plot_t:
     )
 
 
-def _Pie(values: array_t, *_, **kwargs) -> backend_plot_t:
+def _BarH(*args, **kwargs) -> backend_plot_t:
     """"""
-    return plly.Pie(values=values, **kwargs)
+    return _BarV(*args, orientation="h", **kwargs)
+
+
+def _BarV(*args, **kwargs) -> backend_plot_t:
+    """"""
+    if args.__len__() == 1:
+        counts = args[0]
+        positions = tuple(range(counts.__len__()))
+    else:
+        positions, counts = args
+    if kwargs.get("orientation") == "h":
+        positions, counts = counts, positions
+
+    return plly.Bar(x=positions, y=counts, **kwargs)
+
+
+def _ElevationSurface(*args, **kwargs) -> backend_plot_t:
+    """"""
+    if args.__len__() == 1:
+        elevation = args[0]
+        x, y = nmpy.meshgrid(
+            range(elevation.shape[0]), range(elevation.shape[1]), indexing="ij"
+        )
+    else:
+        x, y, elevation = args
+
+    return plly.Surface(contours={}, x=x, y=y, z=elevation, **kwargs)
 
 
 def _Image(image: array_t, *_, **kwargs) -> backend_plot_t:
@@ -419,6 +332,107 @@ def _Image(image: array_t, *_, **kwargs) -> backend_plot_t:
     return plly.Image(z=image, **kwargs)
 
 
+def _IsoContour(*args, **kwargs) -> backend_plot_t:
+    """"""
+    parameters = {
+        "contours_coloring": "lines",
+        "line_width": 2,
+    }
+
+    if args.__len__() == 2:
+        values, value = args
+    else:
+        x, y, values, value = args
+        parameters["x"] = x
+        parameters["y"] = y
+    parameters["z"] = values
+    parameters["contours"] = {
+        "start": value,
+        "end": value,
+        "size": 1,
+        "showlabels": True,
+    }
+
+    parameters.update(kwargs)
+
+    return plly.Contour(**parameters)
+
+
+def _IsoSurface(values: array_t, value: float, *args, **kwargs) -> backend_plot_t:
+    """"""
+    if args.__len__() == 3:
+        x, y, z = args
+    else:
+        x, y, z = nmpy.meshgrid(
+            range(values.shape[0]),
+            range(values.shape[1]),
+            range(values.shape[2]),
+            indexing="ij",
+        )
+
+    parameters = {
+        "surface": {"count": 1},
+        "caps": {"x_show": False, "y_show": False, "z_show": False},
+    }
+    parameters.update(kwargs)
+
+    return plly.Isosurface(
+        x=x.ravel(),
+        y=y.ravel(),
+        z=z.ravel(),
+        value=values.ravel(),
+        isomin=value,
+        isomax=value,
+        **parameters,
+    )
+
+
+def _Mesh(triangles: array_t, vertices: array_t, *_, **kwargs) -> backend_plot_t:
+    """"""
+    return plly.Mesh3d(
+        x=vertices[:, 0],
+        y=vertices[:, 1],
+        z=vertices[:, 2],
+        i=triangles[:, 0],
+        j=triangles[:, 1],
+        k=triangles[:, 2],
+        **kwargs,
+    )
+
+
+def _Pie(values: array_t, *_, **kwargs) -> backend_plot_t:
+    """"""
+    return plly.Pie(values=values, **kwargs)
+
+
+def _Polygon(x: array_t, y: array_t, *_, **kwargs) -> backend_plot_t:
+    """"""
+    x = nmpy.concatenate((x, [x[0]]))
+    y = nmpy.concatenate((y, [y[0]]))
+
+    return plly.Scatter(x=x, y=y, mode="lines", fill="toself", **kwargs)
+
+
+def _Polyline2(x: array_t, y: array_t, *_, **kwargs) -> backend_plot_t:
+    """"""
+    return plly.Scatter(x=x, y=y, mode="lines", **kwargs)
+
+
+def _Polyline3(x: array_t, y: array_t, z: array_t, *_, **kwargs) -> backend_plot_t:
+    """"""
+    return plly.Scatter3d(x=x, y=y, z=z, mode="lines", **kwargs)
+
+
+def _Scatter2(x: array_t, y: array_t, *_, **kwargs) -> backend_plot_t:
+    """"""
+    return plly.Scatter(x=x, y=y, mode="markers", **kwargs)
+
+
+def _Scatter3(x: array_t, y: array_t, z: array_t, *_, **kwargs) -> backend_plot_t:
+    """"""
+    return plly.Scatter3d(x=x, y=y, z=z, mode="markers", **kwargs)
+
+
 def _Text2(text: str, x: float, y: float, *_, **kwargs) -> backend_plot_t:
     """"""
     parameters = {"textposition": "top right"}
@@ -444,32 +458,91 @@ def _Text3(text: str, x: float, y: float, z: float, *_, **kwargs) -> backend_plo
 
 PLOTS = plot_e.NewPlotsTemplate()
 
-PLOTS[plot_e.SCATTER][1] = _Scatter2
-PLOTS[plot_e.POLYLINE][1] = _Polyline2
-PLOTS[plot_e.POLYGON][1] = _Polygon
 PLOTS[plot_e.ARROWS][1] = _Arrows2
-PLOTS[plot_e.ISOSET][1] = _IsoContour
+PLOTS[plot_e.ARROWS][2] = _Arrows3
+PLOTS[plot_e.BAR3][2] = _Bar3
 PLOTS[plot_e.BARH][1] = _BarH
 PLOTS[plot_e.BARV][1] = _BarV
-PLOTS[plot_e.PIE][1] = _Pie
-PLOTS[plot_e.IMAGE][1] = _Image
-PLOTS[plot_e.TEXT][1] = _Text2
-
-PLOTS[plot_e.SCATTER][2] = _Scatter3
-PLOTS[plot_e.POLYLINE][2] = _Polyline3
-PLOTS[plot_e.ARROWS][2] = _Arrows3
 PLOTS[plot_e.ELEVATION][2] = _ElevationSurface
+PLOTS[plot_e.IMAGE][1] = _Image
+PLOTS[plot_e.ISOSET][1] = _IsoContour
 PLOTS[plot_e.ISOSET][2] = _IsoSurface
 PLOTS[plot_e.MESH][2] = _Mesh
-PLOTS[plot_e.BAR3][2] = _Bar3
+PLOTS[plot_e.PIE][1] = _Pie
+PLOTS[plot_e.POLYGON][1] = _Polygon
+PLOTS[plot_e.POLYLINE][1] = _Polyline2
+PLOTS[plot_e.POLYLINE][2] = _Polyline3
+PLOTS[plot_e.SCATTER][1] = _Scatter2
+PLOTS[plot_e.SCATTER][2] = _Scatter3
+PLOTS[plot_e.TEXT][1] = _Text2
 PLOTS[plot_e.TEXT][2] = _Text3
 
 
+def _ApplyGlobalTranslation(
+    kwargs: dict[str, h.Any], who_s_asking: str | h.Callable | None, /
+) -> None:
+    """"""
+    if who_s_asking in (_Scatter2, _Scatter3):
+        marker = {}
+        for passed, wanted in zip(
+            ("color", "opacity", "size", "shape"),
+            ("color", "opacity", "size", "symbol"),
+        ):
+            if (value := kwargs.get(passed)) is not None:
+                marker[wanted] = value
+                del kwargs[passed]
+        if who_s_asking is _Scatter3:
+            # /!\\ Passing one size per sample makes all of them disappear.
+            if ("size" in marker) and not isinstance(marker["size"], int | float):
+                marker["size"] = 0.5 * (min(marker["size"]) + max(marker["size"]))
+            # /!\\ Opacity seems to be all-or-nothing.
+            if "opacity" in marker:
+                del marker["opacity"]
+
+        kwargs["marker"] = marker
+        #
+    elif who_s_asking in (_Arrows2, _Polyline2, _Polyline3):
+        line = {}
+        for passed, wanted in zip(
+            ("color", "opacity", "line_width", "line_style"),
+            ("color", "opacity", "width", "symbol"),
+        ):
+            if (value := kwargs.get(passed)) is not None:
+                line[wanted] = value
+                del kwargs[passed]
+
+        kwargs["line"] = line
+        #
+    elif who_s_asking is _Pie:
+        marker = {}
+        for passed, wanted in zip(("color",), ("colors",)):
+            if (value := kwargs.get(passed)) is not None:
+                marker[wanted] = value
+                del kwargs[passed]
+
+        kwargs["marker"] = marker
+
+
 TRANSLATIONS = {
-    "alpha": "opacity",
     "color_face": "surfacecolor",
+    (_Arrows3, "color"): None,
+    (_BarH, "color"): None,
+    (_BarV, "color"): None,
+    (_ElevationSurface, "color_edge"): None,
+    (_ElevationSurface, "color_face"): None,
+    (_ElevationSurface, "width_edge"): None,
+    (_Image, "colormap"): None,
+    (_IsoContour, "color"): "fillcolor",
+    (_IsoSurface, "color_edge"): None,
     (_IsoSurface, "color_face"): None,
+    (_IsoSurface, "step_size"): None,
+    (_IsoSurface, "width_edge"): None,
+    (_Mesh, "color_edge"): None,
     (_Mesh, "color_face"): "facecolor",
+    (_Mesh, "width_edge"): None,
+    (_Polygon, "color_edge"): None,
+    (_Polygon, "color_face"): "fillcolor",
+    None: _ApplyGlobalTranslation,
 }
 
 

{babelplot-2025.6 → babelplot-2025.7}/package/babelplot/backend/catalog/vedo_.py

@@ -51,7 +51,10 @@ class frame_t(base_frame_t):
 
 @d.dataclass(slots=True, repr=False, eq=False)
 class figure_t(base_figure_t):
-    _NewBackendFigure = backend_figure_t
+
+    def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_t:
+        """"""
+        return backend_figure_t(*args, **kwargs)
 
     def _NewFrame(
         self,

{babelplot-2025.6 → babelplot-2025.7}/package/babelplot/backend/helper/validation.py

@@ -46,6 +46,8 @@ def CheckBackend(backend: str | path_t, /) -> None:
     else:
         print('--- Missing "PLOTS" dictionary')
 
+    # TODO: Check that translations respect the format (to be documented by the way).
+
 
 """
 COPYRIGHT NOTICE

{babelplot-2025.6 → babelplot-2025.7}/package/babelplot/task/showing.py

@@ -4,31 +4,33 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2022
 SEE COPYRIGHT NOTICE BELOW
 """
 
+import gzip
 import os as osys
 import sys as s
 import tempfile as tmpf
 
 from babelplot.constant.project import NAME
 from babelplot.runtime.figure import SHOWN_FIGURES, UN_SHOWN_FIGURES
-from babelplot.type.figure import figure_t
 from PyQt6.QtCore import QUrl as url_t
 from PyQt6.QtWebEngineWidgets import QWebEngineView as widget_t
 from PyQt6.QtWidgets import QApplication as application_t
 
 
-def Show(figure: figure_t, /) -> None:
+def ShowHTMLWithPyQt(html: str | bytes, uid: int, /) -> None:
     """"""
+    if isinstance(html, bytes):
+        html = gzip.decompress(html).decode()
+
     # The application must be instantiated in the same thread/process as the one running
     # exec().
     if (application := application_t.instance()) is None:
         application = application_t(s.argv)
-    application.setApplicationName(f"{NAME}-{id(figure)}")
-    widget = widget_t()
+    application.setApplicationName(f"{NAME}-{uid}")
 
-    html = figure.AsHTML()
-    SetHTMLFromFile = lambda _: _SetHTMLFromFile(_, widget, html)
-    widget.loadFinished.connect(SetHTMLFromFile)
-    widget.setHtml(html)
+    widget = widget_t()
+    SetURLIfNeeded = lambda _: _SetURLIfNeeded(_, html, widget, application)
+    widget.loadFinished.connect(SetURLIfNeeded)
+    widget.setHtml(html)  # Now attempt to set HTML; If failure, then SetURLIfNeeded.
 
     widget.show()
     application.exec()
@@ -39,35 +41,34 @@ def ShowAllFigures(
     modal: bool = True,
 ) -> None:
     """"""
-    # TODO: Is this related to backend thread support (see associated constant)?
-    if all(_.backend_name == "matplotlib" for _ in UN_SHOWN_FIGURES):
-        for figure in UN_SHOWN_FIGURES:
-            figure.AdjustLayout()
-
-        SHOWN_FIGURES.extend(UN_SHOWN_FIGURES)  # /!\ Must be removed when closed.
-        UN_SHOWN_FIGURES.clear()
-
-        import matplotlib.pyplot as pypl  # noqa
+    n_figures = UN_SHOWN_FIGURES.__len__()
+    while n_figures > 0:
+        UN_SHOWN_FIGURES[0].Show(modal=modal and (n_figures == 1))
+        n_figures -= 1
 
-        pypl.show()
-    else:
-        while UN_SHOWN_FIGURES.__len__() > 1:
-            UN_SHOWN_FIGURES[0].Show(modal=False)
-        if UN_SHOWN_FIGURES.__len__() > 0:
-            UN_SHOWN_FIGURES[0].Show(modal=modal)
+    assert UN_SHOWN_FIGURES.__len__() == 0
 
+    if modal:
+        WaitForAllFiguresToBeClosed()
 
-# def CloseFigure(figure: figure_t, /)->None:
-#     """"""
 
+def WaitForAllFiguresToBeClosed() -> None:
+    """"""
+    if SHOWN_FIGURES.__len__() == 0:
+        return
 
-# def CloseAllFigures()->None:
-#     """"""
+    with_processes = tuple(_ for _ in SHOWN_FIGURES if _.showing_process is not None)
+    for figure in with_processes:
+        figure.showing_process.join()
+        figure.AcknowledgeClosure()
 
 
-def _SetHTMLFromFile(success: bool, widget: widget_t, html: str, /) -> None:
+def _SetURLIfNeeded(
+    success: bool, html: str, widget: widget_t, application: application_t, /
+) -> None:
     """
-    From: https://doc.qt.io/qtforpython-6/PySide6/QtWebEngineWidgets/QWebEngineView.html#PySide6.QtWebEngineWidgets.PySide6.QtWebEngineWidgets.QWebEngineView.setHtml
+    From: https://doc.qt.io/qtforpython-6/PySide6/QtWebEngineWidgets/QWebEngineView.html
+          #PySide6.QtWebEngineWidgets.PySide6.QtWebEngineWidgets.QWebEngineView.setHtml
         Content larger than 2 MB cannot be displayed...
         ...
         Thereby, the provided code becomes a URL that exceeds the 2 MB limit set by
@@ -82,9 +83,11 @@ def _SetHTMLFromFile(success: bool, widget: widget_t, html: str, /) -> None:
     with open(transfer.name, "w") as accessor:
         accessor.write(html)
     url = url_t.fromLocalFile(transfer.name)
+
     widget.setUrl(url)
+
     DeleteTemporaryFile = lambda: osys.remove(transfer.name)
-    application_t.instance().lastWindowClosed.connect(DeleteTemporaryFile)
+    application.lastWindowClosed.connect(DeleteTemporaryFile)
 
 
 """

{babelplot-2025.6 → babelplot-2025.7}/package/babelplot/type/backend.py

@@ -74,25 +74,42 @@ class backend_t:
         out_kwargs = {}
 
         for idx, value in enumerate(args):
-            if (translation := translations.get((who_s_asking, idx))) is None:
-                # The passed arg should indeed be an arg.
+            if (translation := translations.get((who_s_asking, idx), -1)) == -1:
+                # No translation needed; Keeping the passed arg.
                 out_args.append(value)
-            else:
+            elif translation is None:
+                # The argument should be discarded.
+                pass
+            else:  # isinstance(translation, str)
                 # The passed arg should actually be a kwarg with name "translation".
                 out_kwargs[translation] = value
 
         from_kwargs_to_args = []
         for key, value in kwargs.items():
             # Search for specific translation (who_s_asking, key) before key alone.
-            if (translation := translations.get((who_s_asking, key))) is None:
-                out_kwargs[translations.get(key, key)] = value
-            elif isinstance(translation, int):
-                from_kwargs_to_args.append((translation, value))
-            else:
+            if (translation := translations.get((who_s_asking, key), -1)) == -1:
+                if (translation := translations.get(key, -1)) == -1:
+                    # No translation needed; Keeping the passed arg.
+                    out_kwargs[key] = value
+                elif translation is None:
+                    # The argument should be discarded.
+                    pass
+                else:  # isinstance(translation, str)
+                    out_kwargs[translation] = value
+            elif translation is None:
+                # The argument should be discarded.
+                pass
+            elif isinstance(translation, str):
                 out_kwargs[translation] = value
-        for value, idx in sorted(from_kwargs_to_args, key=ItemAt(0)):
+            else:  # isinstance(translation, int)
+                from_kwargs_to_args.append((translation, value))
+
+        for idx, value in sorted(from_kwargs_to_args, key=ItemAt(0)):
             out_args.insert(idx, value)
 
+        if (ApplyGlobalTranslation := translations.get(None)) is not None:
+            ApplyGlobalTranslation(out_kwargs, who_s_asking)
+
         return out_args, out_kwargs
 
     def __str__(self) -> str:

{babelplot-2025.6 → babelplot-2025.7}/package/babelplot/type/figure.py

@@ -30,6 +30,7 @@ class figure_t(base_t):
     frames: list[frame_t] = d.field(init=False, default_factory=list)
     locations: list[tuple[int, int]] = d.field(init=False, default_factory=list)
     shape: list[int] = d.field(init=False, default_factory=_DefaultShape)
+    showing_process: process_t | None = d.field(init=False, default=None)
 
     def __post_init__(self) -> None:
         """"""
@@ -62,8 +63,7 @@ class figure_t(base_t):
 
         return output
 
-    @staticmethod
-    def _NewBackendFigure(*args, **kwargs) -> backend_figure_h:
+    def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_h:
         """"""
         raise NotImplementedError
 
@@ -180,10 +180,6 @@ class figure_t(base_t):
         """"""
         raise NotImplementedError
 
-    def AsHTML(self) -> str:
-        """"""
-        raise NotImplementedError
-
     def Clear(self) -> None:
         """"""
         # Do not use a for-loop since self.frames will be modified during looping.
@@ -211,16 +207,20 @@ class figure_t(base_t):
         SHOWN_FIGURES.append(self)  # /!\ Must be removed when closed.
         UN_SHOWN_FIGURES.remove(self)
 
-        if modal:
-            self._BackendShow()
-        else:
-            thread = process_t(target=lambda: self._BackendShow())
-            thread.start()
+        self._BackendShow(modal)
 
-    def _BackendShow(self) -> None:
+    def _BackendShow(self, modal: bool, /) -> None:
         """"""
         raise NotImplementedError
 
+    def AcknowledgeClosure(self) -> None:
+        """"""
+        if self in SHOWN_FIGURES:
+            SHOWN_FIGURES.remove(self)
+        else:
+            assert self in UN_SHOWN_FIGURES
+            UN_SHOWN_FIGURES.remove(self)
+
 
 """
 COPYRIGHT NOTICE

{babelplot-2025.6 → babelplot-2025.7}/package/babelplot/type/plot_type.py

@@ -145,10 +145,10 @@ class plot_e(enum_t):
     )
     SCATTER = (
         "Set of Points",
-        "A set of points X, (X, Y), or (X, Y, Z) depending on the dimension. They are plotted using a so-called "
+        "A set of points (X, Y) or (X, Y, Z) depending on the dimension. They are plotted using a so-called "
         "marker.\n"
         "Required arguments: X coordinates, Y coordinates, Z coordinates (depending on the dimension).",
-        (1, 2, 3),
+        (2, 3),
     )
     TEXT = (
         "Text annotation",

{babelplot-2025.6 → babelplot-2025.7}/package/babelplot/version.py

@@ -4,7 +4,7 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2022
 SEE COPYRIGHT NOTICE BELOW
 """
 
-__version__ = "2025.6"
+__version__ = "2025.7"
 
 """
 COPYRIGHT NOTICE

{babelplot-2025.6 → babelplot-2025.7}/package/babelplot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: babelplot
-Version: 2025.6
+Version: 2025.7
 Summary: A Meta Plotting Library That Speaks Several Backends
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/babelplot/
 Author: Eric Debreuve