plotlp 0.1.2__tar.gz → 0.1.3__tar.gz

{plotlp-0.1.2 → plotlp-0.1.3}/PKG-INFO

@@ -1,17 +1,12 @@
 Metadata-Version: 2.3
 Name: plotlp
-Version: 0.1.2
+Version: 0.1.3
 Summary: A library wrapper around matplotlib for custom plots.
 Requires-Dist: corelp
 Requires-Dist: cycler
-Requires-Dist: ipykernel
 Requires-Dist: matplotlib
-Requires-Dist: pytest
-Requires-Dist: sphinx
-Requires-Dist: sphinx-design
-Requires-Dist: sphinx-rtd-theme
-Requires-Dist: spyder-kernels
-Requires-Dist: toml
+Requires-Dist: numpy
+Requires-Dist: pillow
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 

{plotlp-0.1.2 → plotlp-0.1.3}/pyproject.toml

@@ -1,15 +1,20 @@
 [project]
 name = "plotlp"
-version = "0.1.2"
+version = "0.1.3"
 description = "A library wrapper around matplotlib for custom plots."
 readme = "README.md"
 requires-python = ">=3.12"
-dependencies = [ "corelp", "cycler", "ipykernel", "matplotlib", "pytest", "sphinx", "sphinx-design", "sphinx-rtd-theme", "spyder-kernels", "toml",]
+dependencies = [ "corelp", "cycler", "matplotlib", "numpy", "pillow",]
 
 [build-system]
 requires = [ "uv_build>=0.8.8,<0.9.0",]
 build-backend = "uv_build"
 
+[dependency-groups]
+dev = [ "pytest",]
+docs = [ "sphinx", "sphinx-design", "sphinx-rtd-theme", "toml",]
+anaconda = [ "ipykernel", "spyder-kernels",]
+
 [tool.uv]
 required-environments = [ "sys_platform == 'linux' and platform_machine == 'x86_64'", "sys_platform == 'win32' and (platform_machine == 'AMD64' or platform_machine == 'x86_64')",]
 

plotlp-0.1.3/src/plotlp/modules/StyledAxes_LP/StyledAxes.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-12-11
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : plotLP
+# Module        : StyledAxes
+
+"""
+A class using stored styles inside.
+"""
+
+
+
+# %% Libraries
+from matplotlib.axes import Axes
+from matplotlib import pyplot as plt
+import matplotlib.projections as projections
+import inspect
+from corelp import prop
+import numpy as np
+from matplotlib.patches import Rectangle
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+
+
+# %% Class
+class StyledAxes(Axes) :
+    f'''
+    A class using stored styles inside.
+    
+    Attributes
+    ----------
+    style : dict
+        associated figure style.
+    polish_imscale : bool
+        True to polish automatically imscale
+    polish_grids : bool
+        True to polish automatically grids
+    polish_noborder : bool
+        True to polish automatically no boders
+    polish_equiscale : bool
+        True to polish automatically equiscale
+
+    Examples
+    --------
+    >>> from plotlp import subplots
+    ...
+    >>> fig, axes = subplots(nrows=2, ncols=2) # StyledFigure, StyledAxes
+    >>> axis = fig.axis # StyledAxes, current axis of fig
+    >>> axis.polish() # applies all the polish methods for all the "polish_attr" attributes
+    >>> axis.grids() # applies the polish grids, adds major and minor grids
+    >>> axis.imscale() # applies the polish imscale, sets x and y limits to images borders
+    >>> axis.noborder() # applies the polish no border, removes axis borders
+    >>> axis.equiscale() # applies the polish equiscale, x and y unit have same size on plot
+    >>> axis.implot(image, x, y, w, h) # plots an image to the coordinates, deformes to fit the box defined
+    '''
+
+    name = "styled"
+    @property
+    def style(self) :
+        return self.figure.style
+
+    # Imshow
+    def imshow(self, X, *args, barname=None, coordinates=None, **kwargs) :
+        with plt.style.context(self.style):
+            if coordinates is not None :
+                x, y = coordinates
+                dx, dy = (x[-1]-x[0]) / (len(x)-1) / 2, (y[-1]-y[0]) / (len(y)-1) / 2
+                extent = [x[0]-dx, x[-1]+dx, y[0]-dy, y[-1]+dy]
+                kwargs.update(dict(extent=extent, aspect='auto', origin='lower'))
+            im = super().imshow(X, *args, **kwargs)
+            if coordinates is not None :
+                self.invert_yaxis()
+                Ny, Nx = X.shape
+                self.set_box_aspect(Ny / Nx)
+                self.polish_axis = False
+            if barname is not None :
+                self.figure.colorbar(im, barname=barname)
+
+            return im
+    
+    # Pcolormesh
+    def pcolormesh(self, *args, cmap=None, **kwargs):
+        with plt.style.context(self.style):
+            if cmap is None:
+                cmap = plt.get_cmap(plt.rcParams['image.cmap'])
+            return super().pcolormesh(*args, cmap=cmap, **kwargs)
+
+    # Implot
+    def implot(self, img, x, y, w, h, zorder=3, **kwargs) :
+        newaxe = inset_axes(self, [x, y, w, h], transform=self.transData, zorder=zorder, axes_class=StyledAxes)
+        newaxe.set_axis_off()
+        kw = {'aspect':'auto','extent':[x, x+w, y, y+h],'origin':'lower'}
+        kw.update(kwargs)
+        im = newaxe.imshow(img, **kw)
+        clip_rect = Rectangle((0, 0), 1, 1, transform=self.transAxes, facecolor="none")
+        im.set_clip_path(clip_rect)
+        return im
+
+
+### --- Polish functions ---
+
+
+
+    polish_axis = True
+    def polish(self) :
+        if not self.polish_axis : return
+        if self.polish_grids : self.grids()
+        if self.polish_imscale : self.imscale()
+        if self.polish_noborders : self.noborders()
+        if self.polish_equiscale : self.equiscale()
+
+    # grids
+    @prop()
+    def polish_grids(self) :
+        return len(self.lines) > 0 or len(self.collections) > 0
+    grid_major = {'linestyle':'-', 'alpha':1}
+    grid_minor = {'linestyle':'--', 'alpha':0.5}
+    def grids(self) :
+        with plt.style.context(self.style) :
+            if self.grid_major is not None and len(self.grid_major) > 0 :
+                self.grid(which='major',**self.grid_major)
+            if self.grid_minor is not None and len(self.grid_minor) > 0 :
+                self.minorticks_on() # force enabling minor ticks
+                self.grid(which='minor',**self.grid_minor)
+
+    # imscale
+    @prop()
+    def polish_imscale(self) :
+        return len(self.get_images()) > 0
+    def imscale(self) :
+        with plt.style.context(self.style) :
+            xmax, ymax = 0, 0
+            for image in self.get_images() : # Get maximum image coordinates
+                y, x = np.shape(image.get_array())[0:2]
+                ymax, xmax = max(y, ymax), max(x, xmax)
+            if self.get_autoscalex_on() :
+                self.set_xlim(-0.5, xmax - 0.5)
+            if self.get_autoscaley_on() :
+                self.set_ylim(ymax - 0.5, -0.5)
+
+    # noborders
+    @prop()
+    def polish_noborders(self) :
+        return not self.polish_grids
+    def noborders(self) :
+        with plt.style.context(self.style) :
+            self.set_axis_off()
+
+    # equiscale
+    @prop()
+    def polish_equiscale(self) :
+        return False
+    def equiscale(self) :
+        with plt.style.context(self.style) :
+            self.set_aspect(aspect='equal', adjustable='box')
+    
+
+
+### --- Regenerate parent class methods in the given style ---
+
+
+
+def is_plottable(method_name, method_obj):
+    """
+    Returns True if this method should be wrapped automatically.
+    """
+    if hasattr(StyledAxes, method_name): # Already overriden
+        return False
+    if method_name.startswith("_"):      # private
+        return False                # handled separately
+    if not callable(method_obj):
+        return False
+    if not inspect.ismethoddescriptor(method_obj) and not inspect.isfunction(method_obj):
+        return False
+    # Heuristic: methods returning artists / sequences of artists
+    # Usually are plotting methods; we accept them all here
+    return True
+
+def wrap_method(method_name):
+    """
+    Returns a wrapper method that applies the style context
+    then calls the parent Axes method.
+    """
+    def wrapper(self, *args, **kwargs):
+        with plt.style.context(self.style):
+            method = getattr(super(StyledAxes, self), method_name)
+            return method(*args, **kwargs)
+    wrapper.__name__ = method_name
+    return wrapper
+
+# Dynamically inject each wrapper method into StyledAxes
+for name, obj in Axes.__dict__.items():
+    if is_plottable(name, obj):
+        setattr(StyledAxes, name, wrap_method(name))
+
+# Finally register projection
+projections.register_projection(StyledAxes)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

plotlp-0.1.3/src/plotlp/modules/StyledAxes_LP/test_StyledAxes.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-12-11
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : plotLP
+# Module        : StyledAxes
+
+"""
+This file allows to test StyledAxes
+
+StyledAxes : A class using stored styles inside.
+"""
+
+
+
+# %% Libraries
+from corelp import print, debug
+from plotlp import StyledAxes
+debug_folder = debug(__file__)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

plotlp-0.1.3/src/plotlp/modules/StyledFigure_LP/StyledFigure.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-12-11
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : plotLP
+# Module        : StyledFigure
+
+"""
+A class defining figures with custom styles included inside.
+"""
+
+
+
+# %% Libraries
+from matplotlib.figure import Figure
+from matplotlib import pyplot as plt
+import numpy as np
+from plotlp import style as get_style
+from plotlp import StyledAxes # do not remove even if unused
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+from corelp import selfkwargs, prop
+import gc
+from io import BytesIO
+from pathlib import Path
+from PIL import Image
+import string
+
+
+
+# %% Class
+class StyledFigure(Figure) :
+    f'''
+    A class defining figures with custom styles included inside.
+    
+    Parameters
+    ----------
+    figsize : tuple
+        figure size [inch] (x, y).
+    dpi : int
+        Dots Per Inch resolution.
+    style : str or dict
+        Name of style or corresponding dict.
+    lightmode : bool
+        True to use lightLP style.
+    darkmode : bool
+        True to use darkLP style.
+    kwargs : dict
+        Keyword arguments corresponding to attributes to change.
+
+    Attributes
+    ----------
+    axis : property
+        set as an index, when gotten returns corresponding axis.
+    plot_axes : list
+        list of plotting axes.
+    naxes : int
+        Number of plotting axes.
+    figsize_default : tuple
+        Default figure size (x, y) in inch.
+    figsize_ratio : float
+        x/y figure size ratio, while keeping the same area as default figsize.
+    figsize_fact : tuple
+        (x, y) figure size growing factors.
+    title : property
+        suptitle applied and to apply when set.
+    tight : bool
+        True to apply tight layout when polishing.
+
+    Examples
+    --------
+    >>> from plotlp import figure, plt
+    ...
+    >>> fig = figure() # Savefigure output
+    >>> plt.imshow(image, barname='My colorbar') # Apply barname to auto createe colorbar
+    >>> fig.polish() # Applies StyledAxes automatic polishing on each axis
+    >>> fig.arrayfig(close=False) # Saves figure into an numpy array (calls fig.savefig, close=False to not close figure)
+    >>> plt.savefig(png_path=png_path, close=False, **savefig_kwargs) # saving png only
+    >>> plt.savefig(pdf_path=pdf_path, close=False, **savefig_kwargs) # saving pdf only
+    >>> plt.savefig(path, **savefig_kwargs) # saving png and pdf automatically, close=True by default so no more figure after
+    '''
+
+    def __init__(self, figsize=None, dpi=None, *, style=None, darkmode=False, lightmode=False, **kwargs):
+
+        # Style
+        if style is not None :
+            self.style = style
+        elif lightmode : self.lightmode()
+        elif darkmode : self.darkmode()
+        else :
+            self.style
+
+        # Init
+        with plt.style.context(self.style) :
+            super().__init__(figsize, dpi)
+            selfkwargs(self, kwargs)
+        self.figresize()
+
+
+
+    #Style
+    style_name = 'lightLP'
+    _style = None #style dict
+    style_kwargs = {}
+    @property
+    def style(self) :
+        if self._style is None :
+            self.style = self.style_name
+        return self._style
+    @style.setter
+    def style(self,value) :
+        if isinstance(value,str) :
+            self.style_name = value
+            self._style = get_style(value)
+        else :
+            self.style_name = None
+            self._style = value
+        self._style.update(self.style_kwargs)
+    def lightmode(self) : #to auto call lightmode
+        self.style = 'lightLP'
+    def darkmode(self) : #to auto call darkmode
+        self.style = 'darkLP'
+
+
+
+    #Axe
+    axis_num = 0 #index of axes
+
+    @property
+    def axis(self) :
+        return self.plot_axes[self.axis_num]
+    @axis.setter
+    def axis(self,value) :
+        self.axis_num = value
+        plt.sca(self.plot_axes[self.axis_num])
+
+    @property
+    def naxes(self) :
+        return len(self.plot_axes)
+
+    @property
+    def plot_axes(self) :
+        return [ax for ax in self.axes if not getattr(ax, "is_cbar", False)]
+
+    def add_subplot(self, *args, **kwargs):
+        with plt.style.context(self.style) :
+            kwargs["projection"] = "styled"   # force the Axes type
+            return super().add_subplot(*args, **kwargs)
+    def add_axes(self, *args, **kwargs):
+        with plt.style.context(self.style) :
+            return super().add_axes(*args, **kwargs)
+
+
+
+    # Paper index
+    paper_index_kwargs = {'size': 20, 'weight': 'bold'}
+    def paper_index(self, axes=None, **kwargs) :
+        with plt.style.context(self.style) :
+            if axes is None :
+                axes = self.plot_axes
+            kw = self.paper_index_kwargs.copy()
+            kw.update(kwargs)
+            for n, ax in enumerate(axes):
+                ax.text(-0.1, 1.1, string.ascii_lowercase[n], transform=ax.transAxes, **kw)
+
+
+
+    # Colorbar
+    barname = {'rotation':270,'labelpad':10}
+    cax = {'size':"5%", 'pad':0.05}
+    def colorbar(self, mappable, cax=None, ax=None, barname=None, **kwargs) :
+        with plt.style.context(self.style) :
+            if cax is None :
+                if ax is None :
+                    ax = mappable.axes
+                divider = make_axes_locatable(ax)
+                cax = divider.append_axes("right", **self.cax)
+                cax.is_cbar = True
+            cbar = super().colorbar(mappable=mappable, cax=cax, ax=None, **kwargs)
+            if barname is not None :
+                cbar.ax.set_ylabel(barname, **self.barname)
+            return cbar
+
+
+
+    #figure size parameter
+    @prop()
+    def figsize_default(self) :
+        return self.get_size_inches()
+
+    @prop()
+    def figsize_ratio(self) :
+        x, y = self.figsize_default
+        return x / y
+
+    @prop()
+    def figsize_fact(self) :
+        return 1., 1.
+
+    def figresize(self) :
+        default = self.figsize_default
+        ratio = self.figsize_ratio
+        fact = self.figsize_fact
+        area = default[0] * default[1]
+        y = np.sqrt(area/ratio)
+        x = ratio * y
+        self.set_size_inches(x * fact[0], y * fact[1])
+        self._figsize_default = None
+        self._figsize_ratio = None
+        self._figsize_fact = None
+
+
+
+    # Title
+    @property
+    def title(self) :
+        if getattr(self, '_title', None) is None :
+            return None
+        return self._title.get_text()
+    @title.setter
+    def title(self, value) :
+        with plt.style.context(self.style) :
+            self._title = self.suptitle(value)
+
+
+
+    # Polish
+    tight = True
+    polish_figure = True
+    def polish(self) :
+        with plt.style.context(self.style) :
+            for axis_num in range(self.naxes) :
+                self.axis = axis_num
+                self.axis.polish()
+            if self.tight :
+                self.tight_layout()
+
+
+
+    # Savefig
+    def savefig(self, path=None, *, polish=None, path_png=None, path_pdf=None, close=True, **kwargs) :
+        if polish is True or polish is None and self.polish_figure :
+            self.polish()
+
+        with plt.style.context(self.style) :
+
+            # Saving in array
+            if isinstance(path, BytesIO) :
+                super().savefig(path, **kwargs)
+        
+            # Saving in file
+            else :
+                path_png = Path(path_png) if path_png is not None else Path(path) if path is not None and path.suffix != '.pdf' else None
+                path_pdf = Path(path_pdf) if path_pdf is not None else Path(path) if path is not None and path.suffix != '.png'  else None
+        
+                if path_png is not None :
+                    super().savefig(path_png.with_suffix('.png'), **kwargs)
+                if path_pdf is not None :
+                    super().savefig(path_pdf.with_suffix('.pdf'), **kwargs)
+        
+            # Close figure
+            if close :
+                plt.close(self)
+                gc.collect()
+
+
+
+    #Arrayfig
+    def arrayfig(self, *args, **kwargs) :
+        '''
+        Converts figure into a numpy array
+        '''
+        with plt.style.context(self.style) :
+            with BytesIO() as buf:
+                self.savefig(buf, *args, **kwargs)
+                buf.seek(0)
+                image = Image.open(buf)
+                image_np = np.array(image)
+            return image_np
+
+
+
+    #Show
+    def show(self, *args, **kwargs) :
+        with plt.style.context(self.style) :
+            super().show(*args,**kwargs)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

plotlp-0.1.3/src/plotlp/modules/StyledFigure_LP/test_StyledFigure.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-12-11
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : plotLP
+# Module        : StyledFigure
+
+"""
+This file allows to test StyledFigure
+
+StyledFigure : A class defining figures with custom styles included inside.
+"""
+
+
+
+# %% Libraries
+from corelp import print, debug
+from plotlp import StyledFigure
+debug_folder = debug(__file__)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)