babelplot 2025.10__tar.gz → 2025.12__tar.gz

{babelplot-2025.10 → babelplot-2025.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: babelplot
-Version: 2025.10
+Version: 2025.12
 Summary: A Meta Plotting Library That Speaks Several Backends
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/babelplot/
 Author: Eric Debreuve
@@ -17,7 +17,6 @@ Classifier: Development Status :: 3 - Alpha
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 Requires-Dist: numpy
-Requires-Dist: PyQt6
 Requires-Dist: scikit-image
 Dynamic: author
 Dynamic: author-email
@@ -47,7 +46,7 @@ Dynamic: summary
 .. |DOCUMENTATION_URL| replace:: https://src.koda.cnrs.fr/eric.debreuve/babelplot/-/wikis/home
 .. _DOCUMENTATION_URL: https://src.koda.cnrs.fr/eric.debreuve/babelplot/-/wikis/home
 
-.. |DEPENDENCIES_MANDATORY| replace:: numpy, PyQt6, scikit-image
+.. |DEPENDENCIES_MANDATORY| replace:: numpy, scikit-image
 .. |DEPENDENCIES_OPTIONAL|  replace:: bokeh, matplotlib, plotly, vedo
 
 

{babelplot-2025.10 → babelplot-2025.12}/README.rst

@@ -13,7 +13,7 @@
 .. |DOCUMENTATION_URL| replace:: https://src.koda.cnrs.fr/eric.debreuve/babelplot/-/wikis/home
 .. _DOCUMENTATION_URL: https://src.koda.cnrs.fr/eric.debreuve/babelplot/-/wikis/home
 
-.. |DEPENDENCIES_MANDATORY| replace:: numpy, PyQt6, scikit-image
+.. |DEPENDENCIES_MANDATORY| replace:: numpy, scikit-image
 .. |DEPENDENCIES_OPTIONAL|  replace:: bokeh, matplotlib, plotly, vedo
 
 

babelplot-2025.10/package/babelplot/api/definition.py → babelplot-2025.12/package/babelplot/api/type.py

@@ -4,8 +4,9 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2022
 SEE COPYRIGHT NOTICE BELOW
 """
 
-from babelplot.type.dimension import dim_e  # noqa
-from babelplot.type.plot_type import plot_e  # noqa
+from babelplot.type.figure import figure_t  # noqa
+from babelplot.type.frame import frame_t  # noqa
+from babelplot.type.plot import plot_t  # noqa
 
 """
 COPYRIGHT NOTICE

{babelplot-2025.10 → babelplot-2025.12}/package/babelplot/backend/catalog/bokeh_.py

@@ -9,6 +9,7 @@ import gzip
 import typing as h
 from multiprocessing import Process as process_t
 
+import numpy as nmpy
 from babelplot.task.plotting import NewPlotFunctionsTemplate, SetDefaultPlotFunction
 from babelplot.task.showing import ShowHTMLPlotWithPyQt
 from babelplot.type.dimension import dim_e
@@ -16,7 +17,7 @@ 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_function import plot_function_h
-from babelplot.type.plot_type import plot_e
+from babelplot.type.plot_type import plot_e, plot_type_h
 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
@@ -27,6 +28,8 @@ from bokeh.resources import INLINE  # noqa
 
 NAME = "bokeh"
 
+array_t = nmpy.ndarray
+
 
 class backend_figure_t: ...
 
@@ -43,6 +46,7 @@ class frame_t(base_frame_t):
         plot_function: plot_function_h,
         *args,
         title: str | None = None,  # If _, then it is swallowed by kwargs!
+        type_: tuple[plot_type_h | plot_function_h, int],
         **kwargs,
     ) -> plot_t:
         """"""
@@ -59,9 +63,9 @@ class figure_t(base_figure_t):
 
     layout: h.Any = d.field(init=False, default=None)
 
-    def _NewBackendFigure(self, *args, **kwargs) -> backend_figure_t:
+    def _NewBackendFigure(self, *args, **kwargs) -> None:
         """"""
-        return backend_figure_t()  # self.raw is never used.
+        return None
 
     def _NewFrame(
         self,
@@ -85,7 +89,7 @@ class figure_t(base_figure_t):
         # 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)]
+        arranged_frames: list[list[h.Any]] = [n_cols * [None] for _ in range(n_rows)]
         for frame, (row, col) in zip(self.frames, self.locations):
             raw = frame.raw
             if raw.renderers.__len__() == 0:
@@ -153,18 +157,15 @@ 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}",
+                plot_t.UnhandledRequestMessage(
+                    type_, *args, frame_dim=frame_dim, **kwargs
+                ),
             ),
             text_font_size="30px",
             text_align="center",
@@ -174,16 +175,71 @@ def _DefaultFunction(type_: plot_e, frame_dim: int, /) -> plot_function_h:
     return Actual
 
 
+def _BarH(frame: backend_frame_t, *args, **kwargs) -> backend_plot_t:
+    """"""
+    if args.__len__() == 1:
+        counts = args[0]
+        positions = tuple(range(counts.__len__()))
+    else:
+        positions, counts = args
+
+    return frame.hbar(y=positions, right=counts, **kwargs)
+
+
+def _BarV(frame: backend_frame_t, *args, **kwargs) -> backend_plot_t:
+    """"""
+    if args.__len__() == 1:
+        counts = args[0]
+        positions = tuple(range(counts.__len__()))
+    else:
+        positions, counts = args
+
+    return frame.vbar(x=positions, top=counts, **kwargs)
+
+
+def _Image(frame: backend_frame_t, image: array_t, *args, **kwargs) -> backend_plot_t:
+    """"""
+    if nmpy.issubdtype(image.dtype, nmpy.floating):
+        image = nmpy.round(255.0 * (image / image.max())).astype(nmpy.uint8)
+
+    for_bokeh = nmpy.empty(image.shape[:2], dtype=nmpy.uint32)
+    view = for_bokeh.view(dtype=nmpy.uint8).reshape(image.shape[:2] + (4,))
+
+    if (image.ndim == 2) or (image.shape[2] != 4):
+        if (image.ndim == 2) or (image.shape[2] == 1):
+            planes = (image, image, image)
+        else:
+            planes = (image[..., 0], image[..., 1], image[..., 2])
+        for d_idx in range(3):
+            view[..., d_idx] = planes[d_idx]
+        view[..., 3] = nmpy.full_like(image, 255)
+    else:
+        view[...] = image[...]
+
+    frame.x_range.range_padding = frame.y_range.range_padding = 0
+
+    return frame.image_rgba(
+        image=(for_bokeh,), x=0, y=0, dw=image.shape[1], dh=image.shape[0]
+    )
+
+
 PLOTS = NewPlotFunctionsTemplate()
+PLOTS[plot_e.BARH][0] = _BarH
+PLOTS[plot_e.BARV][0] = _BarV
+PLOTS[plot_e.IMAGE][0] = _Image
 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,
+    None: {
+        "color_face": "fill_color",
+        "opacity": "alpha",
+    },
+    "_NewFrame": {
+        "azimuth": None,
+        "elevation": None,
+    },
 }
 
 

{babelplot-2025.10 → babelplot-2025.12}/package/babelplot/backend/catalog/matplotlib_.py

@@ -108,6 +108,7 @@ class frame_t(base_frame_t):
         plot_function: plot_function_h,
         *args,
         title: str | None = None,  # /!\ If _, then it is swallowed by kwargs!
+        type_: tuple[plot_type_h | plot_function_h, int],
         **kwargs,
     ) -> plot_t:
         """"""
@@ -271,7 +272,7 @@ 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:
+def _Bar3(frame: backend_frame_3d_t, *args, **kwargs) -> backend_plot_t:
     """"""
     if args.__len__() == 1:
         counts = nmpy.asarray(args[0])
@@ -319,7 +320,7 @@ def _BarV(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plots_t:
     return frame.bar(positions, counts, **kwargs)
 
 
-def _ElevationSurface(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
+def _ElevationSurface(frame: backend_frame_3d_t, *args, **kwargs) -> backend_plot_t:
     """"""
     if args.__len__() == 1:
         elevation = args[0]
@@ -347,7 +348,7 @@ def _IsoContour(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
     return output
 
 
-def _IsoSurface(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
+def _IsoSurface(frame: backend_frame_3d_t, *args, **kwargs) -> backend_plot_t:
     """"""
     if "step_size" in kwargs:
         mc_kwargs = {"step_size": kwargs["step_size"]}
@@ -362,9 +363,13 @@ def _IsoSurface(frame: backend_frame_2d_t, *args, **kwargs) -> backend_plot_t:
 
 
 def _Mesh(
-    frame: backend_frame_2d_t, triangles: array_t, vertices: array_t, *_, **kwargs
+    frame: backend_frame_3d_t, triangles: array_t, vertices: array_t, *_, **kwargs
 ) -> backend_plot_t:
-    """"""
+    """
+    Note: As of 3.9.2, plot_trisurf does not support custom triangle colors yet (see
+    https://github.com/matplotlib/matplotlib/blob/v3.9.2/lib/mpl_toolkits/mplot3d/axes3d.py,
+    line 2291).
+    """
     return frame.plot_trisurf(
         vertices[:, 0], vertices[:, 1], triangles, vertices[:, 2], **kwargs
     )
@@ -413,37 +418,52 @@ PLOTS[plot_e.TEXT][1] = _Text3
 
 
 TRANSLATIONS = {
-    "color": "c",
-    "color_edge": "edgecolors",
-    "color_face": "facecolors",
-    "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",
-    ("AddFrame", "azimuth"): "azim",
-    ("AddFrame", "elevation"): "elev",
-    (_Arrows2, "color"): "color",
-    (_Arrows3, "color"): "color",
-    (_Bar3, "color"): "color",
-    (_BarH, "color"): "color",
-    (_BarH, "offset"): "left",
-    (_BarV, "color"): "color",
-    (_BarV, "offset"): "bottom",
-    (_ElevationSurface, "color_face"): "color",
-    (_IsoContour, "color"): "colors",
-    (_IsoSurface, "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",
-    (backend_frame_2d_t.quiver, "color"): "color",
-    (backend_frame_3d_t.quiver, "color"): "colors",
-    (backend_frame_3d_t.scatter, 2): "zs",
+    None: {
+        "color": "c",
+        "color_edge": "edgecolors",
+        "color_face": "facecolors",
+        "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",
+    },
+    "_NewFrame": {
+        "azimuth": "azim",
+        "elevation": "elev",
+    },
+    _Arrows2: {"c": "color"},
+    _Arrows3: {"c": "color"},
+    _Bar3: {"c": "color"},
+    _BarH: {
+        "c": "color",
+        "offset": "left",
+    },
+    _BarV: {
+        "c": "color",
+        "offset": "bottom",
+    },
+    _ElevationSurface: {"facecolors": "color"},
+    _IsoContour: {"c": "colors"},
+    _IsoSurface: {"facecolors": "color"},
+    _Mesh: {
+        "facecolors": (
+            "color",
+            lambda _: NewConvertedColor(_, "hex", sequence_or_reduction=0),
+        )
+    },
+    _Polygon: {
+        "edgecolors": "edgecolor",
+        "facecolors": "facecolor",
+    },
+    backend_frame_2d_t.pie: {"c": "colors"},
+    backend_frame_2d_t.quiver: {"c": "color"},
+    backend_frame_3d_t.quiver: {"c": "colors"},
+    backend_frame_3d_t.scatter: {2: "zs"},
 }
 
 """

{babelplot-2025.10 → babelplot-2025.12}/package/babelplot/backend/catalog/plotly_.py

@@ -13,6 +13,7 @@ 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.color import NColorsAndFormat
 from babelplot.task.plotting import NewPlotFunctionsTemplate
 from babelplot.task.showing import ShowHTMLPlotWithPyQt
 from babelplot.type.dimension import dim_e
@@ -20,8 +21,8 @@ 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_function import plot_function_h
-from babelplot.type.plot_type import plot_e
-from plotly.basedatatypes import BasePlotlyType as backend_plot_t  # noqa
+from babelplot.type.plot_type import plot_e, plot_type_h
+from plotly.basedatatypes import BaseTraceType 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
 
@@ -53,6 +54,7 @@ class frame_t(base_frame_t):
         plot_function: plot_function_h,
         *args,
         title: str | None = None,  # If _, then it is swallowed by kwargs!
+        type_: tuple[plot_type_h | plot_function_h, int],
         **kwargs,
     ) -> plot_t:
         """"""
@@ -94,7 +96,9 @@ class figure_t(base_figure_t):
         n_rows, n_cols = self.shape
         if (n_rows > 1) or (n_cols > 1):
             frame_titles = (n_rows * n_cols) * [""]
-            arranged_plots = [n_cols * [None] for _ in range(n_rows)]
+            arranged_plots: list[list[list[backend_plot_t] | None]] = [
+                n_cols * [None] for _ in range(n_rows)
+            ]
             for frame, (row, col) in zip(self.frames, self.locations):
                 if frame.title is not None:
                     frame_titles[row * n_cols + col] = frame.title
@@ -106,6 +110,7 @@ class figure_t(base_figure_t):
             frame_types = [n_cols * [{}] for _ in range(n_rows)]
             for row, plot_row in enumerate(arranged_plots):
                 for col, plot_cell in enumerate(plot_row):
+                    # Note: Subclasses of backend_plot_t have a type property.
                     frame_types[row][col] = {"type": plot_cell[0].type}
 
             raw = NewMultiAxesFigure(
@@ -334,7 +339,7 @@ def _Image(image: array_t, *_, **kwargs) -> backend_plot_t:
 
 def _IsoContour(*args, **kwargs) -> backend_plot_t:
     """"""
-    parameters = {
+    parameters: dict[str, h.Any] = {
         "contours_coloring": "lines",
         "line_width": 2,
     }
@@ -388,7 +393,10 @@ def _IsoSurface(values: array_t, value: float, *args, **kwargs) -> backend_plot_
 
 
 def _Mesh(triangles: array_t, vertices: array_t, *_, **kwargs) -> backend_plot_t:
-    """"""
+    """
+    Note: Mesh3d does not support setting edge colors. It can be done indirectly by
+    adding a Scatter3d plot.
+    """
     return plly.Mesh3d(
         x=vertices[:, 0],
         y=vertices[:, 1],
@@ -491,6 +499,19 @@ def _ApplyGlobalTranslation(
             if (value := kwargs.get(passed)) is not None:
                 marker[wanted] = value
                 del kwargs[passed]
+        if "color" in marker:
+            n_colors, _ = NColorsAndFormat(marker["color"])
+            if n_colors > 1:
+                # TODO: Currently, works only for RGB color format.
+                colorscale = [
+                    [
+                        _idx / (n_colors - 1),
+                        f"rgb({round(255.0*_red)}, {round(255.0*_grn)}, {round(255.0*_blu)})",
+                    ]
+                    for _idx, (_red, _grn, _blu) in enumerate(marker["color"])
+                ]
+                marker["colorscale"] = colorscale
+                marker["color"] = tuple(_[0] for _ in colorscale)
         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):
@@ -501,11 +522,11 @@ def _ApplyGlobalTranslation(
 
         kwargs["marker"] = marker
         #
-    elif who_s_asking in (_Arrows2, _Polyline2, _Polyline3):
+    elif who_s_asking in (_Arrows2, _Polygon, _Polyline2, _Polyline3):
         line = {}
         for passed, wanted in zip(
-            ("color", "opacity", "line_width", "line_style"),
-            ("color", "opacity", "width", "symbol"),
+            ("color", "color_edge", "opacity", "line_width", "line_style"),
+            ("color", "color", "opacity", "width", "symbol"),
         ):
             if (value := kwargs.get(passed)) is not None:
                 line[wanted] = value
@@ -524,25 +545,24 @@ def _ApplyGlobalTranslation(
 
 
 TRANSLATIONS = {
-    "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,
+    None: {
+        "color_face": "surfacecolor",
+        None: _ApplyGlobalTranslation,
+    },
+    _Arrows3: {"color": None},
+    _BarH: {"color": None},
+    _BarV: {"color": None},
+    _ElevationSurface: {"color_edge": None, "surfacecolor": None, "width_edge": None},
+    _Image: {"colormap": None},
+    _IsoContour: {"color": "fillcolor"},
+    _IsoSurface: {
+        "color_edge": None,
+        "surfacecolor": None,
+        "step_size": None,
+        "width_edge": None,
+    },
+    _Mesh: {"color_edge": None, "surfacecolor": "facecolor", "width_edge": None},
+    _Polygon: {"surfacecolor": "fillcolor"},
 }