babelplot 2025.4__tar.gz → 2025.5__tar.gz

{babelplot-2025.4 → babelplot-2025.5}/PKG-INFO

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

{babelplot-2025.4 → babelplot-2025.5}/package/babelplot/__init__.py

@@ -18,7 +18,9 @@ else:
         beartype_this_package()
 
 from babelplot.task.instantiation import NewFigure, NewPlot
+from babelplot.type.dimension import dim_e
 from babelplot.type.figure import ShowAllFigures
+from babelplot.type.plot_definition import plot_e
 from babelplot.version import __version__
 
 """

{babelplot-2025.4 → babelplot-2025.5}/package/babelplot/api/backend.py

@@ -4,7 +4,6 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2022
 SEE COPYRIGHT NOTICE BELOW
 """
 
-from babelplot.backend.definition.runtime import AddBackendSpecification  # noqa
 from babelplot.backend.helper.creation import PrintBackendDraft  # noqa
 from babelplot.backend.helper.validation import CheckBackend  # noqa
 

babelplot-2025.5/package/babelplot/api/definition.py

@@ -0,0 +1,54 @@
+"""
+Copyright CNRS/Inria/UniCA
+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_definition import plot_e  # noqa
+
+"""
+COPYRIGHT NOTICE
+
+This software is governed by the CeCILL  license under French law and
+abiding by the rules of distribution of free software.  You can  use,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+As a counterpart to the access to the source code and  rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty  and the software's author,  the holder of the
+economic rights,  and the successive licensors  have only  limited
+liability.
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
+
+This software is being developed by Eric Debreuve, a CNRS employee and
+member of team Morpheme.
+Team Morpheme is a joint team between Inria, CNRS, and UniCA.
+It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
+I3S, and Laboratory iBV.
+
+CNRS: https://www.cnrs.fr/index.php/en
+Inria: https://www.inria.fr/en/
+UniCA: https://univ-cotedazur.eu/
+Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
+I3S: https://www.i3s.unice.fr/en/
+iBV: http://ibv.unice.fr/
+Team Morpheme: https://team.inria.fr/morpheme/
+"""

{babelplot-2025.4 → babelplot-2025.5}/package/babelplot/backend/catalog/bokeh_.py

@@ -4,19 +4,16 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2022
 SEE COPYRIGHT NOTICE BELOW
 """
 
-from __future__ import annotations
-
+import dataclasses as d
 import typing as h
 
-from babelplot.backend.definition.backend import backend_e
-from babelplot.definition.dimension import dim_e
-from babelplot.definition.plot import PlotsFromTemplate, plot_e, plot_type_h
 from babelplot.task.show_pyqt6 import Show
+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_definition import PlotsFromTemplate, plot_e, plot_type_h
 from bokeh.embed import file_html as HTMLofBackendContent  # noqa
-from bokeh.layouts import LayoutDOM as backend_content_t  # 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
@@ -24,96 +21,99 @@ from bokeh.models.renderers import GlyphRenderer as backend_plot_t  # noqa
 from bokeh.plotting import figure as backend_figure_t  # noqa
 from bokeh.resources import INLINE  # noqa
 
-NAME = backend_e.BOKEH.value
+# from bokeh.layouts import LayoutDOM as backend_content_t  # noqa
+
+NAME = "bokeh"
 
 
 backend_frame_t = backend_figure_t
 
 
-def _NewPlot(
-    frame: backend_frame_t,
-    type_: plot_type_h | type[backend_plot_t],
-    plot_function: (
-        type[backend_plot_t] | h.Callable[..., backend_plot_t | h.Any] | None
-    ),
-    *args,
-    title: str | None = None,  # If _, then it is swallowed by kwargs!
-    **kwargs,
-) -> tuple[
-    backend_plot_t | h.Any,
-    type[backend_plot_t] | h.Callable[..., backend_plot_t | h.Any],
-]:
-    """"""
-    if plot_function is None:
-        if hasattr(backend_frame_t, type_):
-            plot_function = getattr(backend_frame_t, type_)
-        else:
-            raise ValueError(f"{type_}: Unknown {NAME} graph object.")
-
-    return plot_function(frame, *args, **kwargs), plot_function
-
-
-def _NewFrame(
-    _: backend_figure_t,
-    __: int,
-    ___: int,
-    *args,
-    title: str | None = None,
-    dim: dim_e = dim_e.XY,  # If _, then it is swallowed by kwargs!
-    **kwargs,
-) -> backend_frame_t:
-    """"""
-    return backend_frame_t(*args, title=title, **kwargs)
-
-
-def _AdjustLayout(figure: figure_t, /) -> None:
-    """"""
-    n_rows, n_cols = figure.shape
-    arranged_frames = [n_cols * [None] for _ in range(n_rows)]
-    for frame, (row, col) in zip(figure.frames, figure.locations):
-        arranged_frames[row][col] = frame.backend
-    arranged_frames: list[list[backend_frame_t]]
-
-    if n_rows > 1:
-        if n_cols > 1:
-            layout = NewBackendGridLayout(arranged_frames)
+@d.dataclass(slots=True, repr=False, eq=False)
+class plot_t(base_plot_t): ...
+
+
+@d.dataclass(slots=True, repr=False, eq=False)
+class frame_t(base_frame_t):
+
+    def _NewPlot(
+        self,
+        type_: plot_type_h | type[backend_plot_t],
+        plot_function: (
+            type[backend_plot_t] | h.Callable[..., backend_plot_t | h.Any] | None
+        ),
+        *args,
+        title: str | None = None,  # If _, then it is swallowed by kwargs!
+        **kwargs,
+    ) -> plot_t:
+        """"""
+        output = plot_t(
+            title=title,
+            property=kwargs.copy(),
+            backend_name=self.backend_name,
+        )
+
+        if plot_function is None:
+            if hasattr(backend_frame_t, type_):
+                plot_function = getattr(backend_frame_t, type_)
+            else:
+                raise ValueError(f"{type_}: Unknown {NAME} graph object.")
+
+        output.backend_type = plot_function
+        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
+
+    _NewBackendFigure = backend_figure_t
+    _BackendShow = Show
+
+    def _NewFrame(
+        self,
+        row: int,
+        col: int,
+        *args,
+        title: str | None = None,
+        dim: dim_e = dim_e.XY,  # If _, then it is swallowed by kwargs!
+        **kwargs,
+    ) -> frame_t:
+        """"""
+        output = frame_t(
+            title=title,
+            dim=dim,
+            backend_name=self.backend_name,
+        )
+
+        output.raw = backend_frame_t(*args, title=title, **kwargs)
+
+        return output
+
+    def AdjustLayout(self) -> None:
+        """"""
+        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]]
+
+        if n_rows > 1:
+            if n_cols > 1:
+                layout = NewBackendGridLayout(arranged_frames)
+            else:
+                column = [_row[0] for _row in arranged_frames]
+                layout = NewBackendColLayout(column)
         else:
-            column = [_row[0] for _row in arranged_frames]
-            layout = NewBackendColLayout(column)
-    else:
-        layout = NewBackendRowLayout(arranged_frames[0])
-
-    figure.layout = layout
-
-
-def _AsHTML(figure: figure_t, /) -> str:
-    """"""
-
-    return HTMLofBackendContent(figure.layout, INLINE)
-
-
-# noinspection PyTypeChecker
-plot_t: type[base_plot_t] = type("plot_t", (base_plot_t,), {})
-# noinspection PyTypeChecker
-frame_t: type[base_frame_t] = type(
-    "frame_t",
-    (base_frame_t,),
-    {"plot_class": plot_t, "NewBackendPlot": staticmethod(_NewPlot)},
-)
-# noinspection PyTypeChecker
-figure_t: type[base_figure_t] = type(
-    "figure_t",
-    (base_figure_t,),
-    {
-        "frame_class": frame_t,
-        "NewBackendFigure": backend_figure_t,
-        "NewBackendFrame": staticmethod(_NewFrame),
-        "AdjustLayout": _AdjustLayout,
-        "BackendShow": Show,
-        "layout": None,
-        "AsHTML": _AsHTML,
-    },
-)
+            layout = NewBackendRowLayout(arranged_frames[0])
+
+        self.layout = layout
+
+    def AsHTML(self) -> str:
+        """"""
+        return HTMLofBackendContent(self.layout, INLINE)
 
 
 PLOTS = PlotsFromTemplate()

{babelplot-2025.4 → babelplot-2025.5}/package/babelplot/backend/catalog/matplotlib_.py

@@ -4,20 +4,18 @@ Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2022
 SEE COPYRIGHT NOTICE BELOW
 """
 
-from __future__ import annotations
-
+import dataclasses as d
 import typing as h
 
 import matplotlib.pyplot as pypl  # noqa
 import numpy as nmpy
 import skimage.measure as msre
-from babelplot.backend.definition.backend import backend_e
-from babelplot.definition.dimension import dim_e
-from babelplot.definition.plot import PlotsFromTemplate, plot_e, plot_type_h
 from babelplot.type.base import backend_element_h
+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_definition import PlotsFromTemplate, 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
@@ -31,108 +29,13 @@ from mpl_toolkits.mplot3d import Axes3D as backend_frame_3d_t  # noqa
 
 import matplotlib as mlpl  # noqa
 
-NAME = backend_e.MATPLOTLIB.value
+NAME = "matplotlib"
 
 
 array_t = nmpy.ndarray
 backend_frame_h = backend_frame_2d_t | backend_frame_3d_t
 
 
-def _NewPlot(
-    frame: backend_frame_h,
-    type_: plot_type_h | type[backend_plot_t],
-    plot_function: (
-        type[backend_plot_t] | h.Callable[..., backend_plot_t | h.Any] | None
-    ),
-    *args,
-    title: str | None = None,  # /!\ If _, then it is swallowed by kwargs!
-    **kwargs,
-) -> tuple[
-    backend_plot_t | h.Any,
-    type[backend_plot_t] | h.Callable[..., backend_plot_t | h.Any],
-]:
-    """"""
-    if plot_function is None:
-        # Next, priority is given to 2-D plots... which might be a problem if a 2-D and
-        # 3-D frame have plot types with the same name. For example, scatter in 2-D and
-        # 3-D.
-        if hasattr(backend_frame_2d_t, type_):
-            plot_function = getattr(backend_frame_2d_t, type_)
-        elif hasattr(backend_frame_3d_t, type_):
-            plot_function = getattr(backend_frame_3d_t, type_)
-        else:
-            raise ValueError(f"{type_}: Unknown {NAME} graph object.")
-
-    return plot_function(frame, *args, **kwargs), plot_function
-
-
-def _NewFrame(
-    figure: backend_figure_t,
-    _: int,
-    __: int,
-    *args,
-    title: str | None = None,
-    dim: dim_e = dim_e.XY,
-    **kwargs,
-) -> backend_frame_h:
-    """"""
-    if dim is dim_e.XY:
-        output = figure.subplots(*args, **kwargs)
-    elif dim is dim_e.XYZ:
-        # See note below
-        output = backend_frame_3d_t(figure, *args, auto_add_to_figure=False, **kwargs)
-        figure.add_axes(output)
-    else:
-        raise NotImplementedError(f"{dim}: Dimension management not implemented yet")
-    if title is not None:
-        output.set_title(title)
-
-    return output
-
-
-def _AdjustLayout(figure: figure_t, /) -> None:
-    """"""
-    raw_figure = figure.backend
-
-    if figure.title is not None:
-        raw_figure.suptitle(figure.title)
-    for frame in figure.frames:
-        if frame.title is not None:
-            frame.backend.set_title(frame.title)
-        for plot in frame.plots:
-            if plot.title is not None:
-                plot.backend.set_label(plot.title)
-
-    if figure.frames.__len__() < 2:
-        return
-
-    grid_spec = grid_spec_t(*figure.shape, figure=raw_figure)
-    bottoms, tops, lefts, rights = grid_spec.get_grid_positions(raw_figure)
-
-    for frame, (row, col) in zip(figure.frames, figure.locations):
-        left, bottom, width, height = (
-            lefts[col],
-            bottoms[row],
-            rights[col] - lefts[col],
-            tops[row] - bottoms[row],
-        )
-        frame.backend.set_position((left, bottom, width, height))
-
-
-def _Show(
-    figure: figure_t,
-    /,
-) -> None:
-    """"""
-    raw = figure.backend
-
-    raw.show()
-
-    event_manager = raw.canvas
-    event_manager.mpl_connect("close_event", lambda _: event_manager.stop_event_loop())
-    event_manager.start_event_loop()
-
-
 def _DefaultProperties(type_: h.Callable, /) -> dict[str, h.Any]:
     """"""
     name = type_.__name__
@@ -151,16 +54,16 @@ def _SetProperty(
     if isinstance(element, h.Sequence):
         elements = element
         for element in elements:
-            _SetProperty(element, name, value)
+            _SetProperty(element.raw, name, value)
         return
 
     if name == "marker":
         new_marker = marker_style_t(value)
-        element.set_paths((new_marker.get_path(),))
+        element.raw.set_paths((new_marker.get_path(),))
     else:
         property_ = {name: value}
         try:
-            pypl.setp(element, **property_)
+            pypl.setp(element.raw, **property_)
         except AttributeError:
             L.error(
                 f'Property "{name}": Invalid property for element of type "{type(element).__name__}"'
@@ -172,10 +75,10 @@ def _Property(
 ) -> h.Any:
     """"""
     if isinstance(element, h.Sequence):
-        return _Property(element[0], name)
+        return _Property(element[0].raw, name)
 
     try:
-        output = pypl.getp(element, property=name)
+        output = pypl.getp(element.raw, property=name)
     except AttributeError:
         output = None
         L.error(
@@ -185,41 +88,136 @@ def _Property(
     return output
 
 
-# noinspection PyTypeChecker
-plot_t: type[base_plot_t] = type(
-    "plot_t",
-    (base_plot_t,),
-    {
-        "BackendDefaultProperties": staticmethod(_DefaultProperties),
-        "BackendSetProperty": staticmethod(_SetProperty),
-        "BackendProperty": staticmethod(_Property),
-    },
-)
-# noinspection PyTypeChecker
-frame_t: type[base_frame_t] = type(
-    "frame_t",
-    (base_frame_t,),
-    {
-        "plot_class": plot_t,
-        "NewBackendPlot": staticmethod(_NewPlot),
-        "BackendSetProperty": staticmethod(_SetProperty),
-        "BackendProperty": staticmethod(_Property),
-    },
-)
-# noinspection PyTypeChecker
-figure_t: type[base_figure_t] = type(
-    "figure_t",
-    (base_figure_t,),
-    {
-        "frame_class": frame_t,
-        "NewBackendFigure": staticmethod(NewBackendFigure),
-        "NewBackendFrame": staticmethod(_NewFrame),
-        "AdjustLayout": _AdjustLayout,
-        "BackendShow": _Show,
-        "BackendSetProperty": staticmethod(_SetProperty),
-        "BackendProperty": staticmethod(_Property),
-    },
-)
+@d.dataclass(slots=True, repr=False, eq=False)
+class plot_t(base_plot_t):
+    _BackendDefaultProperties: h.ClassVar[h.Callable] = _DefaultProperties
+    _BackendSetProperty: h.ClassVar[h.Callable] = _SetProperty
+    _BackendProperty: h.ClassVar[h.Callable] = _Property
+
+
+@d.dataclass(slots=True, repr=False, eq=False)
+class frame_t(base_frame_t):
+    _BackendSetProperty: h.ClassVar[h.Callable] = _SetProperty
+    _BackendProperty: h.ClassVar[h.Callable] = _Property
+
+    def _NewPlot(
+        self,
+        type_: plot_type_h | type[backend_plot_t],
+        plot_function: (
+            type[backend_plot_t] | h.Callable[..., backend_plot_t | h.Any] | None
+        ),
+        *args,
+        title: str | None = None,  # /!\ If _, then it is swallowed by kwargs!
+        **kwargs,
+    ) -> plot_t:
+        """"""
+        output = plot_t(
+            title=title,
+            property=kwargs.copy(),
+            backend_name=self.backend_name,
+        )
+
+        if plot_function is None:
+            # Next, priority is given to 2-D plots... which might be a problem if a 2-D and
+            # 3-D frame have plot types with the same name. For example, scatter in 2-D and
+            # 3-D.
+            if hasattr(backend_frame_2d_t, type_):
+                plot_function = getattr(backend_frame_2d_t, type_)
+            elif hasattr(backend_frame_3d_t, type_):
+                plot_function = getattr(backend_frame_3d_t, type_)
+            else:
+                raise ValueError(f"{type_}: Unknown {NAME} graph object.")
+
+        output.backend_type = plot_function
+        output.raw = plot_function(self.raw, *args, **kwargs)
+
+        return output
+
+
+@d.dataclass(slots=True, repr=False, eq=False)
+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:
+        """"""
+        return NewBackendFigure(*args, num=None, **kwargs)
+
+    def _NewFrame(
+        self,
+        title: str | None,
+        dim: dim_e,
+        row: int,
+        col: int,
+        *args,
+        **kwargs,
+    ) -> frame_t:
+        """"""
+        output = frame_t(
+            title=title,
+            dim=dim,
+            backend_name=self.backend_name,
+        )
+
+        if dim is dim_e.XY:
+            raw = self.raw.subplots(*args, **kwargs)
+        elif dim is dim_e.XYZ:
+            # See note below
+            raw = backend_frame_3d_t(
+                self.raw, *args, auto_add_to_figure=False, **kwargs
+            )
+            self.raw.add_axes(raw)
+        else:
+            raise NotImplementedError(
+                f"{dim}: Dimension management not implemented yet"
+            )
+        if title is not None:
+            raw.set_title(title)
+
+        output.raw = raw
+
+        return output
+
+    def AdjustLayout(self) -> None:
+        """"""
+        raw = self.raw
+
+        if self.title is not None:
+            raw.suptitle(self.title)
+        for frame in self.frames:
+            if frame.title is not None:
+                frame.raw.set_title(frame.title)
+            for plot in frame.plots:
+                if plot.title is not None:
+                    plot.raw.set_label(plot.title)
+
+        if self.frames.__len__() < 2:
+            return
+
+        grid_spec = grid_spec_t(*self.shape, figure=raw)
+        bottoms, tops, lefts, rights = grid_spec.get_grid_positions(raw)
+
+        for frame, (row, col) in zip(self.frames, self.locations):
+            left, bottom, width, height = (
+                lefts[col],
+                bottoms[row],
+                rights[col] - lefts[col],
+                tops[row] - bottoms[row],
+            )
+            frame.raw.set_position((left, bottom, width, height))
+
+    def _BackendShow(self) -> 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()
 
 
 def _Polygon(
@@ -442,30 +440,30 @@ TRANSLATIONS = {
     (backend_frame_3d_t.scatter, 2): "zs",
 }
 
+"""
+From: https://matplotlib.org/stable/api/prev_api_changes/api_changes_3.4.0.html
+*Axes3D automatically adding itself to Figure is deprecated*
 
-# From: https://matplotlib.org/stable/api/prev_api_changes/api_changes_3.4.0.html
-# *Axes3D automatically adding itself to Figure is deprecated*
-#
-# New Axes3D objects previously added themselves to figures when they were created,
-# unlike all other Axes classes, which lead to them being added twice if
-# fig.add_subplot(111, projection='3d') was called.
-#
-# This behavior is now deprecated and will warn. The new keyword argument
-# auto_add_to_figure controls the behavior and can be used to suppress the warning. The
-# default value will change to False in Matplotlib 3.5, and any non-False value will be
-# an error in Matplotlib 3.6.
-#
-# In the future, Axes3D will need to be explicitly added to the figure
-#
-# fig = Figure()
-# ax = Axes3d(fig)
-# fig.add_axes(ax)
-#
-# as needs to be done for other axes.Axes subclasses. Or, a 3D projection can be made
-# via:
-#
-# fig.add_subplot(projection='3d')
+New Axes3D objects previously added themselves to figures when they were created,
+unlike all other Axes classes, which lead to them being added twice if
+fig.add_subplot(111, projection='3d') was called.
 
+This behavior is now deprecated and will warn. The new keyword argument
+auto_add_to_figure controls the behavior and can be used to suppress the warning. The
+default value will change to False in Matplotlib 3.5, and any non-False value will be
+an error in Matplotlib 3.6.
+
+In the future, Axes3D will need to be explicitly added to the figure
+
+fig = Figure()
+ax = Axes3d(fig)
+fig.add_axes(ax)
+
+as needs to be done for other axes.Axes subclasses. Or, a 3D projection can be made
+via:
+
+fig.add_subplot(projection='3d')
+"""
 
 """
 COPYRIGHT NOTICE