babelplot 2025.7__tar.gz → 2025.9__tar.gz

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

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

{babelplot-2025.7 → babelplot-2025.9}/package/babelplot/__init__.py

@@ -18,7 +18,7 @@ else:
         beartype_this_package()
 
 from babelplot.task.instantiation import NewFigure, NewPlot
-from babelplot.task.showing import ShowAllFigures
+from babelplot.task.showing import ShowFigures
 from babelplot.type.dimension import dim_e
 from babelplot.type.plot_type import plot_e
 from babelplot.version import __version__

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

@@ -7,26 +7,27 @@ SEE COPYRIGHT NOTICE BELOW
 import dataclasses as d
 import typing as h
 
-from babelplot.task.showing import ShowHTMLWithPyQt
+from babelplot.runtime.application import QT_APPLICATION
+from babelplot.task.plotting import NewPlotFunctionsTemplate, SetDefaultPlotFunction
+from babelplot.task.showing import NewPyQtWidgetWithHTML, widget_t
 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
 from babelplot.type.plot import plot_t as base_plot_t
-from babelplot.type.plot_type import plot_e, plot_function_h
+from babelplot.type.plot_function import plot_function_h
+from babelplot.type.plot_type import plot_e
 from bokeh.embed import file_html as HTMLofBackendContent  # noqa
 from bokeh.layouts import column as NewBackendColLayout  # noqa
 from bokeh.layouts import grid as NewBackendGridLayout  # noqa
 from bokeh.layouts import row as NewBackendRowLayout  # noqa
 from bokeh.models.renderers import GlyphRenderer as backend_plot_t  # noqa
-from bokeh.plotting import figure as backend_figure_t  # noqa
+from bokeh.plotting import figure as backend_frame_t  # noqa
 from bokeh.resources import INLINE  # noqa
 
-# from bokeh.layouts import LayoutDOM as backend_content_t  # noqa
-
 NAME = "bokeh"
 
 
-backend_frame_t = backend_figure_t
+class backend_figure_t: ...
 
 
 @d.dataclass(slots=True, repr=False, eq=False)
@@ -44,26 +45,23 @@ class frame_t(base_frame_t):
         **kwargs,
     ) -> plot_t:
         """"""
-        output = plot_t(
+        return plot_t(
             title=title,
             property=kwargs.copy(),
             backend_name=self.backend_name,
+            raw=plot_function(self.raw, *args, **kwargs),
         )
 
-        output.raw = plot_function(self.raw, *args, **kwargs)
-
-        return output
-
 
 @d.dataclass(slots=True, repr=False, eq=False)
 class figure_t(base_figure_t):
-    layout: h.Any = None
 
-    _BackendShow = ShowHTMLWithPyQt
+    widget: widget_t | None = d.field(init=False, default=None)
+    layout: h.Any = d.field(init=False, default=None)
 
     def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_t:
         """"""
-        return backend_figure_t(*args, **kwargs)
+        return backend_figure_t()  # self.raw is never used.
 
     def _NewFrame(
         self,
@@ -75,23 +73,45 @@ class figure_t(base_figure_t):
         **kwargs,
     ) -> frame_t:
         """"""
-        output = frame_t(
+        return frame_t(
             title=title,
             dim=dim,
             backend_name=self.backend_name,
+            raw=backend_frame_t(title=title, **kwargs),
         )
 
-        output.raw = backend_frame_t(*args, title=title, **kwargs)
-
-        return output
-
     def AdjustLayout(self) -> None:
         """"""
+        # arranged_frames must be composed of list since Bokeh does not support tuples
+        # here!
         n_rows, n_cols = self.shape
         arranged_frames = [n_cols * [None] for _ in range(n_rows)]
         for frame, (row, col) in zip(self.frames, self.locations):
-            arranged_frames[row][col] = frame.raw
-        arranged_frames: list[list[backend_frame_t]]
+            raw = frame.raw
+            if raw.renderers.__len__() == 0:
+                _ = backend_frame_t.text(
+                    raw,
+                    x=(0,),
+                    y=(0,),
+                    text=("Empty Frame",),
+                    text_font_size="30px",
+                    text_color="#FF0000",
+                )
+            arranged_frames[row][col] = raw
+
+        # Bokeh does not support inserting None as an indicator of empty space. As a
+        # workaround, the frames are currently flattened (and None_s are filtered out).
+        should_be_filtered = False
+        for one_row in arranged_frames:
+            if any(_ is None for _ in one_row):
+                should_be_filtered = True
+                break
+        if should_be_filtered:
+            arranged_frames = [_ for one_row in arranged_frames for _ in one_row]
+            arranged_frames = list(filter(lambda _: _ is not None, arranged_frames))
+            arranged_frames = [arranged_frames]
+            n_rows = 1
+            n_cols = arranged_frames[0].__len__()
 
         if n_rows > 1:
             if n_cols > 1:
@@ -104,17 +124,61 @@ class figure_t(base_figure_t):
 
         self.layout = layout
 
-    def AsHTML(self) -> str:
+    def _BackendShow(self, modal: bool, /) -> None:
         """"""
-        return HTMLofBackendContent(self.layout, INLINE)
+        try:
+            html = HTMLofBackendContent(self.layout, INLINE)
+        except ValueError as exception:
+            html = f"""
+                <!DOCTYPE html>
+                <html>
+                <body>
+                    <h1>Figure cannot be shown</h1>
+                    <p>{str(exception)}</p>
+                </body>
+                </html>
+            """
+        self.widget = NewPyQtWidgetWithHTML(html)
+
+        if modal:
+            QT_APPLICATION.exec()
+
+
+def _DefaultFunction(type_: plot_e, frame_dim: int, /) -> plot_function_h:
+    """"""
+
+    def Actual(frame: backend_frame_t, *args, **kwargs) -> backend_plot_t:
+        """"""
+        args = ", ".join(map(lambda _: type(_).__name__, args))
+        kwargs = ", ".join(
+            f"{_key}={type(_vle).__name__}" for _key, _vle in kwargs.items()
+        )
+
+        return backend_frame_t.text(
+            frame,
+            x=(0,),
+            y=(0,),
+            text=(
+                f"Unhandled Plot Request\n{type_.name}.{frame_dim}\nargs: {args}\nkwargs: {kwargs}",
+            ),
+            text_font_size="30px",
+            text_align="center",
+            text_color="#FF0000",
+        )
+
+    return Actual
 
 
-PLOTS = plot_e.NewPlotsTemplate()
-PLOTS[plot_e.SCATTER][1] = backend_frame_t.scatter
+PLOTS = NewPlotFunctionsTemplate()
+PLOTS[plot_e.SCATTER][0] = backend_frame_t.scatter
+SetDefaultPlotFunction(PLOTS, _DefaultFunction)
 
 
 TRANSLATIONS = {
     "color_face": "fill_color",
+    "opacity": "alpha",
+    ("AddFrame", "azimuth"): None,
+    ("AddFrame", "elevation"): None,
 }
 
 

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

@@ -5,17 +5,22 @@ SEE COPYRIGHT NOTICE BELOW
 """
 
 import dataclasses as d
+import importlib as mprt
 import typing as h
 
 import matplotlib.pyplot as pypl  # noqa
 import numpy as nmpy
 import skimage.measure as msre
+from babelplot.constant.path import QT_RUNTIME_PY_PATH
+from babelplot.task.color import NewConvertedColor
+from babelplot.task.plotting import NewPlotFunctionsTemplate
 from babelplot.type.dimension import dim_e
 from babelplot.type.ffp_base import backend_element_h
 from babelplot.type.figure import figure_t as base_figure_t
 from babelplot.type.frame import frame_t as base_frame_t
 from babelplot.type.plot import plot_t as base_plot_t
-from babelplot.type.plot_type import plot_e, plot_function_h, plot_type_h
+from babelplot.type.plot_function import plot_function_h
+from babelplot.type.plot_type import plot_e, plot_type_h
 from logger_36 import L
 from matplotlib.artist import Artist as backend_plot_t  # noqa
 from matplotlib.container import Container as backend_plots_t  # noqa
@@ -27,6 +32,7 @@ from matplotlib.pyplot import Figure as backend_figure_t  # noqa
 from matplotlib.pyplot import figure as NewBackendFigure  # noqa
 from mpl_toolkits.mplot3d import Axes3D as backend_frame_3d_t  # noqa
 
+import matplotlib as mtpl  # noqa
 import matplotlib as mlpl  # noqa
 
 NAME = "matplotlib"
@@ -108,16 +114,13 @@ class frame_t(base_frame_t):
         **kwargs,
     ) -> plot_t:
         """"""
-        output = plot_t(
+        return plot_t(
             title=title,
             property=kwargs.copy(),
             backend_name=self.backend_name,
+            raw=plot_function(self.raw, *args, **kwargs),
         )
 
-        output.raw = plot_function(self.raw, *args, **kwargs)
-
-        return output
-
 
 @d.dataclass(slots=True, repr=False, eq=False)
 class figure_t(base_figure_t):
@@ -126,11 +129,7 @@ class figure_t(base_figure_t):
 
     def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_t:
         """"""
-        output = NewBackendFigure(*args, num=None, **kwargs)
-
-        output.canvas.mpl_connect("close_event", lambda *_, **__: _OnCloseEvent(self))
-
-        return output
+        return NewBackendFigure(*args, num=None, **kwargs)
 
     def _NewFrame(
         self,
@@ -204,25 +203,27 @@ class figure_t(base_figure_t):
 
     def _BackendShow(self, modal: bool, /) -> None:
         """"""
-        raw = self.raw
-        raw.show()
+        self.raw.show()
 
         if modal:
-            title = raw.get_suptitle()
-            if title.__len__() > 0:
-                title = f"{title} [MASTER FIGURE]"
+            if "qt" in mtpl.get_backend().lower():
+                module = mprt.import_module(QT_RUNTIME_PY_PATH)
+                module.QT_APPLICATION.exec()
             else:
-                title = "MASTER FIGURE"
-            raw.suptitle(title)
+                event_manager = self.raw.canvas
+                event_manager.mpl_connect("close_event", _OnCloseEvent)
+                event_manager.start_event_loop()
 
-            raw.canvas.start_event_loop()
 
-
-def _OnCloseEvent(figure: figure_t, /) -> None:
+def _OnCloseEvent(event: h.Any, /) -> None:
     """"""
-    # Hopefully, the event loop does not mind being stopped several times.
-    figure.raw.canvas.stop_event_loop()
-    figure.AcknowledgeClosure()
+    event.canvas.stop_event_loop()
+
+    figures = tuple(map(pypl.figure, pypl.get_fignums()))
+    if figures.__len__() > 0:
+        event_manager = figures[0].canvas
+        event_manager.mpl_connect("close_event", _OnCloseEvent)
+        event_manager.start_event_loop()
 
 
 def _Arrows2(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
@@ -390,26 +391,26 @@ def _Text3(frame: backend_frame_2d_t, text, x, y, z, *_, **kwargs) -> backend_pl
     return frame.text(x, y, z, text, **kwargs)
 
 
-PLOTS = plot_e.NewPlotsTemplate()
-
-PLOTS[plot_e.ARROWS][1] = _Arrows2
-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.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.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
+PLOTS = NewPlotFunctionsTemplate()
+
+PLOTS[plot_e.ARROWS][0] = _Arrows2
+PLOTS[plot_e.ARROWS][1] = _Arrows3
+PLOTS[plot_e.BAR3][1] = _Bar3
+PLOTS[plot_e.BARH][0] = _BarH
+PLOTS[plot_e.BARV][0] = _BarV
+PLOTS[plot_e.ELEVATION][1] = _ElevationSurface
+PLOTS[plot_e.IMAGE][0] = backend_frame_2d_t.matshow
+PLOTS[plot_e.ISOSET][0] = _IsoContour
+PLOTS[plot_e.ISOSET][1] = _IsoSurface
+PLOTS[plot_e.MESH][1] = _Mesh
+PLOTS[plot_e.PIE][0] = backend_frame_2d_t.pie
+PLOTS[plot_e.POLYGON][0] = _Polygon
+PLOTS[plot_e.POLYLINE][0] = backend_frame_2d_t.plot
+PLOTS[plot_e.POLYLINE][1] = backend_frame_3d_t.plot
+PLOTS[plot_e.SCATTER][0] = backend_frame_2d_t.scatter
+PLOTS[plot_e.SCATTER][1] = backend_frame_3d_t.scatter
+PLOTS[plot_e.TEXT][0] = _Text2
+PLOTS[plot_e.TEXT][1] = _Text3
 
 
 TRANSLATIONS = {
@@ -437,7 +438,7 @@ TRANSLATIONS = {
     (_ElevationSurface, "color_face"): "color",
     (_IsoContour, "color"): "colors",
     (_IsoSurface, "color_face"): "color",
-    (_Mesh, "color_face"): "color",
+    (_Mesh, "color_face"): ("color", lambda _: NewConvertedColor(_, "hex", 0)),
     (_Polygon, "color_edge"): "edgecolor",
     (_Polygon, "color_face"): "facecolor",
     (backend_frame_2d_t.pie, "color"): "colors",

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

@@ -5,20 +5,21 @@ 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 ShowHTMLWithPyQt
+from babelplot.runtime.application import QT_APPLICATION
+from babelplot.task.plotting import NewPlotFunctionsTemplate
+from babelplot.task.showing import NewPyQtWidgetWithHTML, widget_t
 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
 from babelplot.type.plot import plot_t as base_plot_t
-from babelplot.type.plot_type import plot_e, plot_function_h
+from babelplot.type.plot_function import plot_function_h
+from babelplot.type.plot_type import plot_e
 from plotly.basedatatypes import BasePlotlyType as backend_plot_t  # noqa
 from plotly.graph_objects import Figure as backend_figure_t  # noqa
 from plotly.subplots import make_subplots as NewMultiAxesFigure  # noqa
@@ -30,7 +31,7 @@ array_t = nmpy.ndarray
 
 
 _FIGURE_CONFIG = {
-    "toImageButtonOptions": {  # TODO: Does not work: no PNG export produced
+    "toImageButtonOptions": {  # TODO: No PNG export produced actually.
         "filename": str(path_t.home() / "plotly_figure"),
         "height": None,
         "width": None,
@@ -54,20 +55,19 @@ class frame_t(base_frame_t):
         **kwargs,
     ) -> plot_t:
         """"""
-        output = plot_t(
+        return plot_t(
             title=title,
             property=kwargs.copy(),
             backend_name=self.backend_name,
+            raw=plot_function(*args, **kwargs),
         )
 
-        output.raw = plot_function(*args, **kwargs)
-
-        return output
-
 
 @d.dataclass(slots=True, repr=False, eq=False)
 class figure_t(base_figure_t):
 
+    widget: widget_t | None = d.field(init=False, default=None)
+
     def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_t:
         """"""
         return backend_figure_t(*args, **kwargs)
@@ -138,19 +138,15 @@ class figure_t(base_figure_t):
         Note on include_plotlyjs:
             - "cdn": works but must be online.
             - True => blank figure if using
-              PySide6.QtWebEngineWidgets.QWebEngineView.setHtml because of html size limit.
-                See note in babelplot.task.html.Show.
+              PySide6.QtWebEngineWidgets.QWebEngineView.setHtml because of html size
+              limit.
+              See note in babelplot.task.html.Show.
         """
         html = self.raw.to_html(include_plotlyjs=True, config=_FIGURE_CONFIG)
-        uid = id(self)
+        self.widget = NewPyQtWidgetWithHTML(html)
+
         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
+            QT_APPLICATION.exec()
 
 
 def _Arrows2(*args, **kwargs) -> backend_plot_t:
@@ -456,26 +452,26 @@ def _Text3(text: str, x: float, y: float, z: float, *_, **kwargs) -> backend_plo
     )
 
 
-PLOTS = plot_e.NewPlotsTemplate()
-
-PLOTS[plot_e.ARROWS][1] = _Arrows2
-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.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.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
+PLOTS = NewPlotFunctionsTemplate()
+
+PLOTS[plot_e.ARROWS][0] = _Arrows2
+PLOTS[plot_e.ARROWS][1] = _Arrows3
+PLOTS[plot_e.BAR3][1] = _Bar3
+PLOTS[plot_e.BARH][0] = _BarH
+PLOTS[plot_e.BARV][0] = _BarV
+PLOTS[plot_e.ELEVATION][1] = _ElevationSurface
+PLOTS[plot_e.IMAGE][0] = _Image
+PLOTS[plot_e.ISOSET][0] = _IsoContour
+PLOTS[plot_e.ISOSET][1] = _IsoSurface
+PLOTS[plot_e.MESH][1] = _Mesh
+PLOTS[plot_e.PIE][0] = _Pie
+PLOTS[plot_e.POLYGON][0] = _Polygon
+PLOTS[plot_e.POLYLINE][0] = _Polyline2
+PLOTS[plot_e.POLYLINE][1] = _Polyline3
+PLOTS[plot_e.SCATTER][0] = _Scatter2
+PLOTS[plot_e.SCATTER][1] = _Scatter3
+PLOTS[plot_e.TEXT][0] = _Text2
+PLOTS[plot_e.TEXT][1] = _Text3
 
 
 def _ApplyGlobalTranslation(

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

@@ -6,12 +6,14 @@ SEE COPYRIGHT NOTICE BELOW
 
 import dataclasses as d
 
-import vedo  # noqa
+from babelplot.task.color import NewConvertedColor
+from babelplot.task.plotting import NewPlotFunctionsTemplate
 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
 from babelplot.type.plot import plot_t as base_plot_t
-from babelplot.type.plot_type import plot_e, plot_function_h
+from babelplot.type.plot_function import plot_function_h
+from babelplot.type.plot_type import plot_e
 from numpy import ndarray as array_t
 from vedo import Mesh as backend_plot_t  # noqa
 from vedo import Plotter as backend_figure_t  # noqa
@@ -39,12 +41,11 @@ class frame_t(base_frame_t):
             title=title,
             property=kwargs.copy(),
             backend_name=self.backend_name,
+            raw=plot_function(*args, **kwargs),
         )
 
-        raw = plot_function(*args, **kwargs)
-        self.raw.__iadd__(raw)
-
-        output.raw = raw
+        if output.raw is not None:
+            self.raw.__iadd__(output.raw)
 
         return output
 
@@ -72,13 +73,15 @@ class figure_t(base_figure_t):
             backend_name=self.backend_name,
         )
 
-        output.raw = self
+        output.raw = self.raw
 
         return output
 
-    def _Show(self) -> None:
+    def _BackendShow(self, modal: bool, /) -> None:
         """"""
-        self.raw.show().close()
+        # Passing self.raw.show().close shows the figures one by one.
+        BackendShow = lambda: self.raw.show().close()
+        self._LaunchBackendShow(modal, BackendShow)
 
 
 def _IsoSurface(volume: array_t, iso_value: float, *_, **kwargs) -> backend_plot_t:
@@ -86,11 +89,32 @@ def _IsoSurface(volume: array_t, iso_value: float, *_, **kwargs) -> backend_plot
     return volume_t(volume).isosurface(value=[iso_value], **kwargs)
 
 
-PLOTS = plot_e.NewPlotsTemplate()
-PLOTS[plot_e.ISOSET][2] = _IsoSurface
+def _Mesh(triangles: array_t, vertices: array_t, *_, **kwargs) -> backend_plot_t:
+    """"""
+    output = backend_plot_t((vertices, triangles))
+
+    if "width_edge" in kwargs:
+        output.linewidth(kwargs["width_edge"])
+    if "color_edge" in kwargs:
+        output.linecolor(kwargs["color_edge"])
+    if "color_face" in kwargs:
+        output.color(c=kwargs["color_face"])
+
+    return output
+
+
+PLOTS = NewPlotFunctionsTemplate()
+PLOTS[plot_e.ISOSET][1] = _IsoSurface
+PLOTS[plot_e.MESH][1] = _Mesh
 
 
-TRANSLATIONS = {}
+TRANSLATIONS = {
+    (_IsoSurface, "color_edge"): None,
+    (_IsoSurface, "color_face"): None,
+    (_IsoSurface, "step_size"): None,
+    (_IsoSurface, "width_edge"): None,
+    (_Mesh, "color_face"): ("color_face", lambda _: NewConvertedColor(_, "hex", 0)),
+}
 
 
 """

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

@@ -7,9 +7,11 @@ SEE COPYRIGHT NOTICE BELOW
 import importlib as mprt
 import importlib.util as mput
 import sys as s
+import typing as h
 from pathlib import Path as path_t
 
 from babelplot.runtime.backends import BACKENDS
+from babelplot.type.plot_function import plot_functions_h
 from babelplot.type.plot_type import plot_e
 
 
@@ -36,7 +38,7 @@ def CheckBackend(backend: str | path_t, /) -> None:
     if hasattr(module, "PLOTS"):
         defined = getattr(module, "PLOTS")
         if isinstance(defined, dict):
-            issues = plot_e.PlotsIssues(defined)
+            issues = _PlotFunctionsIssues(defined)
             if issues is not None:
                 print(f"--- PLOTS:\n    ", "\n    ".join(issues), sep="")
         else:
@@ -49,6 +51,56 @@ def CheckBackend(backend: str | path_t, /) -> None:
     # TODO: Check that translations respect the format (to be documented by the way).
 
 
+def _PlotFunctionsIssues(plots: plot_functions_h, /) -> h.Sequence[str] | None:
+    """"""
+    issues = []
+
+    for key, value in plots.items():
+        if not isinstance(key, plot_e):
+            issues.append(
+                f"{key}/{type(key).__name__}: Invalid plot type. "
+                f"Expected={plot_e.__name__}."
+            )
+            continue
+
+        if not isinstance(value, list | tuple):
+            issues.append(
+                f"{key}/{type(value).__name__}: Invalid plot record type. "
+                f"Expected=list or tuple."
+            )
+            continue
+
+        value = tuple(filter(lambda _: _ is not None, value))
+
+        how_defined = key.value
+        if (n_dimensions := value.__len__()) != (
+            n_required := how_defined[2].__len__()
+        ):
+            issues.append(
+                f"{key}: Invalid number of possible dimensions {n_dimensions}. "
+                f"Expected={n_required}."
+            )
+            continue
+
+        for d_idx, for_dim in enumerate(value):
+            if not callable(for_dim):
+                issues.append(
+                    f"{key}/{for_dim}: Invalid plot function "
+                    f"for dim {how_defined[2][d_idx]}. "
+                    f"Expected=Callable."
+                )
+
+    missing = set(plot_e.__members__.values()).difference(plots.keys())
+    if missing.__len__() > 0:
+        missing = str(sorted(_elm.name for _elm in missing))[1:-1].replace("'", "")
+        issues.append(f"Missing plot type(s): {missing}")
+
+    if issues.__len__() > 0:
+        return issues
+
+    return None
+
+
 """
 COPYRIGHT NOTICE
 

{babelplot-2025.7 → babelplot-2025.9}/package/babelplot/constant/path.py

@@ -5,7 +5,7 @@ SEE COPYRIGHT NOTICE BELOW
 """
 
 BACKEND_CATALOG_PY_PATH = "babelplot.backend.catalog"
-
+QT_RUNTIME_PY_PATH = "babelplot.runtime.application"
 
 """
 COPYRIGHT NOTICE