maxplotlibx 0.1.1__tar.gz → 0.1.3__tar.gz

{maxplotlibx-0.1.1 → maxplotlibx-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxplotlibx
-Version: 0.1.1
+Version: 0.1.3
 Summary: A reproducible plotting module with various backends and export options.
 Author: Max
 Project-URL: Source, https://github.com/max-models/maxplotlib
@@ -12,6 +12,7 @@ License-File: LICENSE
 Requires-Dist: matplotlib
 Requires-Dist: pint
 Requires-Dist: plotly
+Requires-Dist: tikzpics>=0.1.1
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: coverage; extra == "test"

{maxplotlibx-0.1.1 → maxplotlibx-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maxplotlibx"
-version = "0.1.1"
+version = "0.1.3"
 description = "A reproducible plotting module with various backends and export options."
 readme = "README.md"
 requires-python = ">=3.8"
@@ -18,6 +18,7 @@ dependencies = [
     "matplotlib",
     "pint",
     "plotly",
+    "tikzpics>=0.1.1",
 ]
 [project.optional-dependencies]
 test = [

{maxplotlibx-0.1.1 → maxplotlibx-0.1.3}/src/maxplotlib/backends/matplotlib/utils.py

@@ -1,18 +1,9 @@
 # import sys; from os.path import dirname; sys.path.append(f'{dirname(__file__)}/../../')
 
 # import matplotlib.pylab as pylab
-import math
-import pickle
-from pathlib import Path
 
-import _pickle as cPickle
-import matplotlib.colors as mcolors
 import matplotlib.pyplot as plt
-import numpy as np
 import pint
-from matplotlib.collections import PatchCollection
-from mpl_toolkits.mplot3d import Axes3D
-from mpl_toolkits.mplot3d.art3d import Line3DCollection, Poly3DCollection
 
 
 def setup_tex_fonts(fontsize=14, usetex=False):
@@ -65,19 +56,30 @@ def convert_to_inches(length_str):
     return quantity.to("inch").magnitude  # Convert to inches
 
 
-def _2pt(width, dpi=300):
+def _2pt(width, dpi=300, verbose: bool = False):
+    if verbose:
+        print(f"Converting width: {width} to points with dpi={dpi}")
+
     if isinstance(width, (int, float)):
         return width
     elif isinstance(width, str):
         length_in = convert_to_inches(width)
         length_pt = length_in * dpi
-        # print(f"{length_in = } {length_pt = }")
+        if verbose:
+            print(f"Converted length: {length_in} inches = {length_pt} points")
         return length_pt
     else:
         raise NotImplementedError
 
 
-def set_size(width, fraction=1, ratio="golden", dpi=300):
+# TODO: Use literal types for width and ratio
+def set_size(
+    width: str,
+    fraction: int | float = 1,
+    ratio: str | int | float = "golden",
+    dpi=300,
+    verbose: bool = False,
+) -> tuple:
     """
     Sets figure dimensions to avoid scaling in LaTeX.
     """
@@ -86,9 +88,11 @@ def set_size(width, fraction=1, ratio="golden", dpi=300):
     elif width == "beamer":
         width_pt = 307.28987
     else:
-        width_pt = _2pt(width=width, dpi=dpi)
+        width_pt = _2pt(width=width, dpi=dpi, verbose=verbose)
 
     fig_width_pt = width_pt * fraction
+    inches_per_pt = 1 / 72.27
+    # fig_width_pt = width_pt * fraction
     # inches_per_pt = 1 / 72.27
 
     # Calculate the figure height based on the desired ratio
@@ -101,7 +105,11 @@ def set_size(width, fraction=1, ratio="golden", dpi=300):
         fig_height_pt = fig_width_pt * ratio
     else:
         raise ValueError("Invalid ratio specified.")
-    fig_dim = (fig_width_pt, fig_height_pt)
+
+    # Convert from points to inches for matplotlib
+    fig_width_in = fig_width_pt * inches_per_pt
+    fig_height_in = fig_height_pt * inches_per_pt
+    fig_dim = (fig_width_in, fig_height_in)
     return fig_dim
 
 

{maxplotlibx-0.1.1 → maxplotlibx-0.1.3}/src/maxplotlib/canvas/canvas.py

@@ -1,17 +1,20 @@
 import os
+import re
 from typing import Dict
 
+import matplotlib.patches as patches
 import matplotlib.pyplot as plt
-import plotly.graph_objects as go
 from plotly.subplots import make_subplots
+from tikzpics import TikzFigure
 
 from maxplotlib.backends.matplotlib.utils import (
     set_size,
     setup_plotstyle,
     setup_tex_fonts,
 )
+from maxplotlib.colors.colors import Color
+from maxplotlib.linestyle.linestyle import Linestyle
 from maxplotlib.subfigure.line_plot import LinePlot
-from maxplotlib.subfigure.tikz_figure import TikzFigure
 from maxplotlib.utils.options import Backends
 
 
@@ -145,8 +148,6 @@ class Canvas:
 
         # Initialize the LinePlot for the given subplot position
         tikz_figure = TikzFigure(
-            col=col,
-            row=row,
             label=label,
             **kwargs,
         )
@@ -225,7 +226,6 @@ class Canvas:
         layers: list | None = None,
         layer_by_layer: bool = False,
         verbose: bool = False,
-        plot: bool = True,
     ):
         filename_no_extension, extension = os.path.splitext(filename)
         if backend == "matplotlib":
@@ -254,7 +254,6 @@ class Canvas:
                 else:
 
                     fig, axs = self.plot(
-                        show=False,
                         backend="matplotlib",
                         savefig=True,
                         layers=layers,
@@ -263,30 +262,68 @@ class Canvas:
                 if verbose:
                     print(f"Saved {full_filepath}")
 
-    def plot(self, backend: Backends = "matplotlib", savefig=False, layers=None):
+    def plot(
+        self,
+        backend: Backends = "matplotlib",
+        savefig=False,
+        layers=None,
+        verbose: bool = False,
+    ):
+        if verbose:
+            print(f"Plotting figure using backend: {backend}")
+
         if backend == "matplotlib":
-            return self.plot_matplotlib(savefig=savefig, layers=layers)
+            return self.plot_matplotlib(
+                savefig=savefig,
+                layers=layers,
+                verbose=verbose,
+            )
         elif backend == "plotly":
             return self.plot_plotly(savefig=savefig)
+        elif backend == "tikzpics":
+            return self.plot_tikzpics(savefig=savefig)
         else:
             raise ValueError(f"Invalid backend: {backend}")
 
-    def show(self, backend="matplotlib"):
+    def show(
+        self,
+        backend: Backends = "matplotlib",
+        verbose: bool = False,
+    ):
+        if verbose:
+            print(f"Showing figure using backend: {backend}")
+
         if backend == "matplotlib":
-            self.plot(backend="matplotlib", savefig=False, layers=None)
-            self._matplotlib_fig.show()
+            self.plot(
+                backend="matplotlib",
+                savefig=False,
+                layers=None,
+                verbose=verbose,
+            )
+            # self._matplotlib_fig.show()
         elif backend == "plotly":
-            plot = self.plot_plotly(savefig=False)
+            self.plot_plotly(savefig=False)
+        elif backend == "tikzpics":
+            fig = self.plot_tikzpics(savefig=False)
+            fig.show()
         else:
             raise ValueError("Invalid backend")
 
-    def plot_matplotlib(self, savefig=False, layers=None, usetex=False):
+    def plot_matplotlib(
+        self,
+        savefig: bool = False,
+        layers: list | None = None,
+        usetex: bool = False,
+        verbose: bool = False,
+    ):
         """
         Generate and optionally display the subplots.
 
         Parameters:
         filename (str, optional): Filename to save the figure.
         """
+        if verbose:
+            print("Generating Matplotlib figure...")
 
         tex_fonts = setup_tex_fonts(fontsize=self.fontsize, usetex=usetex)
 
@@ -297,7 +334,9 @@ class Canvas:
             grid_alpha=1.0,
             grid_linestyle="dotted",
         )
-
+        if verbose:
+            print("Plot style set up.")
+            print(f"{self._figsize = } {self._width = } {self._ratio = }")
         if self._figsize is not None:
             fig_width, fig_height = self._figsize
         else:
@@ -305,21 +344,25 @@ class Canvas:
                 width=self._width,
                 ratio=self._ratio,
                 dpi=self.dpi,
+                verbose=verbose,
             )
-
-        # print(f"{(fig_width / self._dpi, fig_height / self._dpi) = }")
+        if verbose:
+            print(f"Figure size: {fig_width} x {fig_height} points")
 
         fig, axes = plt.subplots(
             self.nrows,
             self.ncols,
             figsize=(fig_width, fig_height),
             squeeze=False,
-            dpi=self._dpi,
+            dpi=self.dpi,
         )
 
         for (row, col), subplot in self.subplots.items():
             ax = axes[row][col]
-            subplot.plot_matplotlib(ax, layers=layers)
+            if isinstance(subplot, TikzFigure):
+                plot_matplotlib(subplot, ax, layers=layers)
+            else:
+                subplot.plot_matplotlib(ax, layers=layers)
             # ax.set_title(f"Subplot ({row}, {col})")
             ax.grid()
 
@@ -329,6 +372,22 @@ class Canvas:
         self._matplotlib_axes = axes
         return fig, axes
 
+    def plot_tikzpics(
+        self,
+        savefig=None,
+        verbose=False,
+    ) -> TikzFigure:
+        if len(self.subplots) > 1:
+            raise NotImplementedError(
+                "Only one subplot is supported for tikzpics backend."
+            )
+        for (row, col), line_plot in self.subplots.items():
+            if verbose:
+                print(f"Plotting subplot at row {row}, col {col}")
+                print(f"{line_plot = }")
+            tikz_subplot = line_plot.plot_tikzpics(verbose=verbose)
+        return tikz_subplot
+
     def plot_plotly(self, show=True, savefig=None, usetex=False):
         """
         Generate and optionally display the subplots using Plotly.
@@ -338,7 +397,7 @@ class Canvas:
         savefig (str, optional): Filename to save the figure if provided.
         """
 
-        tex_fonts = setup_tex_fonts(
+        setup_tex_fonts(
             fontsize=self.fontsize,
             usetex=usetex,
         )  # adjust or redefine for Plotly if needed
@@ -423,9 +482,6 @@ class Canvas:
         return self._subplot_matrix
 
     # Property setters
-    @nrows.setter
-    def dpi(self, value):
-        self._dpi = value
 
     @nrows.setter
     def nrows(self, value):
@@ -472,75 +528,140 @@ class Canvas:
             raise IndexError("Subplot index out of range")
         self._subplot_matrix[row][col] = value
 
-    # def generate_matplotlib_code(self):
-    #     """Generate code for plotting the data using matplotlib."""
-    #     code = "import matplotlib.pyplot as plt\n\n"
-    #     code += f"fig, axes = plt.subplots({self.nrows}, {self.ncols}, figsize={self.figsize})\n\n"
-    #     if self.nrows == 1 and self.ncols == 1:
-    #         code += "axes = [axes]  # Single subplot\n\n"
-    #     else:
-    #         code += "axes = axes.flatten()\n\n"
-    #     for idx, (subplot_idx, lines) in enumerate(self.subplots.items()):
-    #         code += f"# Subplot {subplot_idx}\n"
-    #         code += f"ax = axes[{idx}]\n"
-    #         for line in lines:
-    #             x_data = line['x']
-    #             y_data = line['y']
-    #             label = line['label']
-    #             kwargs = line.get('kwargs', {})
-    #             kwargs_str = ', '.join(f"{k}={repr(v)}" for k, v in kwargs.items())
-    #             code += f"ax.plot({x_data}, {y_data}, label={repr(label)}"
-    #             if kwargs_str:
-    #                 code += f", {kwargs_str}"
-    #             code += ")\n"
-    #         code += "ax.set_xlabel('X-axis')\n"
-    #         code += "ax.set_ylabel('Y-axis')\n"
-    #         if self.nrows * self.ncols > 1:
-    #             code += f"ax.set_title('Subplot {subplot_idx}')\n"
-    #         code += "ax.legend()\n\n"
-    #     code += "plt.tight_layout()\nplt.show()\n"
-    #     return code
-
-    # def generate_latex_plot(self):
-    #     """Generate LaTeX code for plotting the data using pgfplots in subplots."""
-    #     latex_code = "\\begin{figure}[h!]\n\\centering\n"
-    #     total_subplots = self.nrows * self.ncols
-    #     for idx in range(total_subplots):
-    #         subplot_idx = divmod(idx, self.ncols)
-    #         lines = self.subplots.get(subplot_idx, [])
-    #         if not lines:
-    #             continue  # Skip empty subplots
-    #         latex_code += "\\begin{subfigure}[b]{0.45\\textwidth}\n"
-    #         latex_code += "    \\begin{tikzpicture}\n"
-    #         latex_code += "        \\begin{axis}[\n"
-    #         latex_code += "            xlabel={X-axis},\n"
-    #         latex_code += "            ylabel={Y-axis},\n"
-    #         if self.nrows * self.ncols > 1:
-    #             latex_code += f"            title={{Subplot {subplot_idx}}},\n"
-    #         latex_code += "            legend style={at={(1.05,1)}, anchor=north west},\n"
-    #         latex_code += "            legend entries={" + ", ".join(f"{{{line['label']}}}" for line in lines) + "}\n"
-    #         latex_code += "        ]\n"
-    #         for line in lines:
-    #             options = []
-    #             kwargs = line.get('kwargs', {})
-    #             if 'color' in kwargs:
-    #                 options.append(f"color={kwargs['color']}")
-    #             if 'linestyle' in kwargs:
-    #                 linestyle_map = {'-': 'solid', '--': 'dashed', '-.': 'dash dot', ':': 'dotted'}
-    #                 linestyle = linestyle_map.get(kwargs['linestyle'], kwargs['linestyle'])
-    #                 options.append(f"style={linestyle}")
-    #             options_str = f"[{', '.join(options)}]" if options else ""
-    #             latex_code += f"        \\addplot {options_str} coordinates {{\n"
-    #             for x, y in zip(line['x'], line['y']):
-    #                 latex_code += f"            ({x}, {y})\n"
-    #             latex_code += "        };\n"
-    #         latex_code += "        \\end{axis}\n"
-    #         latex_code += "    \\end{tikzpicture}\n"
-    #         latex_code += "\\end{subfigure}\n"
-    #         latex_code += "\\hfill\n" if (idx + 1) % self.ncols != 0 else "\n"
-    #     latex_code += "\\caption{Multiple Subplots}\n"
-    #     latex_code += "\\end{figure}\n"
-    #     return latex_code
+
+def plot_matplotlib(tikzfigure: TikzFigure, ax, layers=None):
+    """
+    Plot all nodes and paths on the provided axis using Matplotlib.
+
+    Parameters:
+    - ax (matplotlib.axes.Axes): Axis on which to plot the figure.
+    """
+
+    # TODO: Specify which layers to retreive nodes from with layers=layers
+    nodes = tikzfigure.layers.get_nodes()
+    paths = tikzfigure.layers.get_paths()
+
+    for path in paths:
+        x_coords = [node.x for node in path.nodes]
+        y_coords = [node.y for node in path.nodes]
+
+        # Parse path color
+        path_color_spec = path.kwargs.get("color", "black")
+        try:
+            color = Color(path_color_spec).to_rgb()
+        except ValueError as e:
+            print(e)
+            color = "black"
+
+        # Parse line width
+        line_width_spec = path.kwargs.get("line_width", 1)
+        if isinstance(line_width_spec, str):
+            match = re.match(r"([\d.]+)(pt)?", line_width_spec)
+            if match:
+                line_width = float(match.group(1))
+            else:
+                print(
+                    f"Invalid line width specification: '{line_width_spec}', defaulting to 1",
+                )
+                line_width = 1
+        else:
+            line_width = float(line_width_spec)
+
+        # Parse line style using Linestyle class
+        style_spec = path.kwargs.get("style", "solid")
+        linestyle = Linestyle(style_spec).to_matplotlib()
+
+        ax.plot(
+            x_coords,
+            y_coords,
+            color=color,
+            linewidth=line_width,
+            linestyle=linestyle,
+            zorder=1,  # Lower z-order to place behind nodes
+        )
+
+    # Plot nodes after paths so they appear on top
+    for node in nodes:
+        # Determine shape and size
+        shape = node.kwargs.get("shape", "circle")
+        fill_color_spec = node.kwargs.get("fill", "white")
+        edge_color_spec = node.kwargs.get("draw", "black")
+        linewidth = float(node.kwargs.get("line_width", 1))
+        size = float(node.kwargs.get("size", 1))
+
+        # Parse colors using the Color class
+        try:
+            facecolor = Color(fill_color_spec).to_rgb()
+        except ValueError as e:
+            print(e)
+            facecolor = "white"
+
+        try:
+            edgecolor = Color(edge_color_spec).to_rgb()
+        except ValueError as e:
+            print(e)
+            edgecolor = "black"
+
+        # Plot shapes
+        if shape == "circle":
+            radius = size / 2
+            circle = patches.Circle(
+                (node.x, node.y),
+                radius,
+                facecolor=facecolor,
+                edgecolor=edgecolor,
+                linewidth=linewidth,
+                zorder=2,  # Higher z-order to place on top of paths
+            )
+            ax.add_patch(circle)
+        elif shape == "rectangle":
+            width = height = size
+            rect = patches.Rectangle(
+                (node.x - width / 2, node.y - height / 2),
+                width,
+                height,
+                facecolor=facecolor,
+                edgecolor=edgecolor,
+                linewidth=linewidth,
+                zorder=2,  # Higher z-order
+            )
+            ax.add_patch(rect)
+        else:
+            # Default to circle if shape is unknown
+            radius = size / 2
+            circle = patches.Circle(
+                (node.x, node.y),
+                radius,
+                facecolor=facecolor,
+                edgecolor=edgecolor,
+                linewidth=linewidth,
+                zorder=2,
+            )
+            ax.add_patch(circle)
+
+        # Add text inside the shape
+        if node.content:
+            ax.text(
+                node.x,
+                node.y,
+                node.content,
+                fontsize=10,
+                ha="center",
+                va="center",
+                wrap=True,
+                zorder=3,  # Even higher z-order for text
+            )
+
+    # Remove axes, ticks, and legend
+    ax.axis("off")
+
+    # Adjust plot limits
+    all_x = [node.x for node in nodes]
+    all_y = [node.y for node in nodes]
+    padding = 1  # Adjust padding as needed
+    ax.set_xlim(min(all_x) - padding, max(all_x) + padding)
+    ax.set_ylim(min(all_y) - padding, max(all_y) + padding)
+    ax.set_aspect("equal", adjustable="datalim")
 
 
 if __name__ == "__main__":

{maxplotlibx-0.1.1 → maxplotlibx-0.1.3}/src/maxplotlib/colors/colors.py

@@ -1,7 +1,6 @@
 import re
 
 import matplotlib.colors as mcolors
-import matplotlib.patches as patches
 import numpy as np
 
 

{maxplotlibx-0.1.1 → maxplotlibx-0.1.3}/src/maxplotlib/subfigure/line_plot.py

@@ -2,9 +2,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import plotly.graph_objects as go
 from mpl_toolkits.axes_grid1 import make_axes_locatable
-
-import maxplotlib.subfigure.tikz_figure as tf
-from maxplotlib.objects.layer import Tikzlayer
+from tikzpics import TikzFigure
 
 
 class Node:
@@ -224,6 +222,21 @@ class LinePlot:
             if self.ymax is not None:
                 ax.axis(ymax=self.ymax)
 
+    def plot_tikzpics(self, layers=None, verbose: bool = False) -> TikzFigure:
+
+        tikz_figure = TikzFigure()
+        for layer_name, layer_lines in self.layered_line_data.items():
+            if layers and layer_name not in layers:
+                continue
+            for line in layer_lines:
+                if line["plot_type"] == "plot":
+                    x = (line["x"] + self._xshift) * self._xscale
+                    y = (line["y"] + self._yshift) * self._yscale
+
+                    nodes = [[xi, yi] for xi, yi in zip(x, y)]
+                    tikz_figure.draw(nodes=nodes, **line["kwargs"])
+        return tikz_figure
+
     def plot_plotly(self):
         """
         Plot all lines using Plotly and return a list of traces for each line.
@@ -255,68 +268,6 @@ class LinePlot:
 
         return traces
 
-    def add_node(self, x, y, label=None, content="", layer=0, **kwargs):
-        """
-        Add a node to the TikZ figure.
-
-        Parameters:
-        - x (float): X-coordinate of the node.
-        - y (float): Y-coordinate of the node.
-        - label (str, optional): Label of the node. If None, a default label will be assigned.
-        - **kwargs: Additional TikZ node options (e.g., shape, color).
-
-        Returns:
-        - node (Node): The Node object that was added.
-        """
-        if label is None:
-            label = f"node{self._node_counter}"
-        node = Node(x=x, y=y, label=label, layer=layer, content=content, **kwargs)
-        self.nodes.append(node)
-        if layer in self.layers:
-            self.layers[layer].add(node)
-        else:
-            # print(f"{self.layers = } {layer = }")
-            self.layers[layer] = Tikzlayer(layer)
-            self.layers[layer].add(node)
-        self._node_counter += 1
-        return node
-
-    def add_path(self, nodes, layer=0, **kwargs):
-        """
-        Add a line or path connecting multiple nodes.
-
-        Parameters:
-        - nodes (list of str): List of node names to connect.
-        - **kwargs: Additional TikZ path options (e.g., style, color).
-
-        Examples:
-        - add_path(['A', 'B', 'C'], color='blue')
-          Connects nodes A -> B -> C with a blue line.
-        """
-        if not isinstance(nodes, list):
-            raise ValueError("nodes parameter must be a list of node names.")
-
-        nodes = [
-            (
-                node
-                if isinstance(node, Node)
-                else (
-                    self.get_node(node)
-                    if isinstance(node, str)
-                    else ValueError(f"Invalid node type: {type(node)}")
-                )
-            )
-            for node in nodes
-        ]
-        path = Path(nodes, **kwargs)
-        self.paths.append(path)
-        if layer in self.layers:
-            self.layers[layer].add(path)
-        else:
-            self.layers[layer] = Tikzlayer(layer)
-            self.layers[layer].add(path)
-        return path
-
     @property
     def xmin(self):
         return self._xmin

maxplotlibx-0.1.3/src/maxplotlib/tests/test_canvas.py

@@ -0,0 +1,6 @@
+def test():
+    pass
+
+
+if __name__ == "__main__":
+    test()

{maxplotlibx-0.1.1 → maxplotlibx-0.1.3}/src/maxplotlib/tests/test_imports.py

@@ -3,9 +3,8 @@ import pytest
 
 @pytest.mark.parametrize("x", [0])
 def import_modules(x):
-    import matplotlib
 
-    import maxplotlib
+    pass
 
 
 if __name__ == "__main__":

maxplotlibx-0.1.3/src/maxplotlib/utils/options.py

@@ -0,0 +1,3 @@
+from typing import Literal
+
+Backends = Literal["matplotlib", "plotly", "tikzpics"]

{maxplotlibx-0.1.1 → maxplotlibx-0.1.3}/src/maxplotlibx.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxplotlibx
-Version: 0.1.1
+Version: 0.1.3
 Summary: A reproducible plotting module with various backends and export options.
 Author: Max
 Project-URL: Source, https://github.com/max-models/maxplotlib
@@ -12,6 +12,7 @@ License-File: LICENSE
 Requires-Dist: matplotlib
 Requires-Dist: pint
 Requires-Dist: plotly
+Requires-Dist: tikzpics>=0.1.1
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: coverage; extra == "test"