maxplotlibx 0.1__py3-none-any.whl

maxplotlib/subfigure/tikz_figure.py

@@ -0,0 +1,497 @@
+import os
+import re
+import subprocess
+import tempfile
+
+import matplotlib.patches as patches
+import numpy as np
+from matplotlib.image import imread
+
+from maxplotlib.colors.colors import Color
+from maxplotlib.linestyle.linestyle import Linestyle
+
+
+class Tikzlayer:
+    def __init__(self, label):
+        self.label = label
+        self.items = []
+
+    def add(self, item):
+        self.items.append(item)
+
+    def get_reqs(self):
+        reqs = set()
+        for item in self.items:
+            if isinstance(item, Path):
+                for node in item.nodes:
+                    if not node.layer == self.label:
+                        reqs.add(node.layer)
+        return reqs
+
+    def generate_tikz(self):
+        tikz_script = f"\n% Layer {self.label}\n"
+        tikz_script += f"\\begin{{pgfonlayer}}{{{self.label}}}\n"
+        for item in self.items:
+            tikz_script += item.to_tikz()
+        tikz_script += f"\\end{{pgfonlayer}}{{{self.label}}}\n"
+        return tikz_script
+
+
+class TikzWrapper:
+    def __init__(self, raw_tikz, label="", content="", layer=0, **kwargs):
+        self.raw_tikz = raw_tikz
+        self.label = label
+        self.content = content
+        self.layer = layer
+        self.options = kwargs
+
+    def to_tikz(self):
+        return self.raw_tikz
+
+
+class Node:
+    def __init__(self, x, y, label="", content="", layer=0, **kwargs):
+        """
+        Represents a TikZ node.
+
+        Parameters:
+        - x (float): X-coordinate of the node.
+        - y (float): Y-coordinate of the node.
+        - name (str, optional): Name of the node. If None, a default name will be assigned.
+        - **kwargs: Additional TikZ node options (e.g., shape, color).
+        """
+        self.x = x
+        self.y = y
+        self.label = label
+        self.content = content
+        self.layer = layer
+        self.options = kwargs
+
+    def to_tikz(self):
+        """
+        Generate the TikZ code for this node.
+
+        Returns:
+        - tikz_str (str): TikZ code string for the node.
+        """
+        options = ", ".join(
+            f"{k.replace('_', ' ')}={v}" for k, v in self.options.items()
+        )
+        if options:
+            options = f"[{options}]"
+        return f"\\node{options} ({self.label}) at ({self.x}, {self.y}) {{{self.content}}};\n"
+
+
+class Path:
+    def __init__(
+        self,
+        nodes,
+        path_actions=[],
+        cycle=False,
+        label="",
+        layer=0,
+        **kwargs,
+    ):
+        """
+        Represents a path (line) connecting multiple nodes.
+
+        Parameters:
+        - nodes (list of str): List of node names to connect.
+        - **kwargs: Additional TikZ path options (e.g., style, color).
+        """
+        self.nodes = nodes
+        self.path_actions = path_actions
+        self.cycle = cycle
+        self.layer = layer
+        self.label = label
+        self.options = kwargs
+
+    def to_tikz(self):
+        """
+        Generate the TikZ code for this path.
+
+        Returns:
+        - tikz_str (str): TikZ code string for the path.
+        """
+        options = ", ".join(
+            f"{k.replace('_', ' ')}={v}" for k, v in self.options.items()
+        )
+        if len(self.path_actions) > 0:
+            options = ", ".join(self.path_actions) + ", " + options
+        if options:
+            options = f"[{options}]"
+        path_str = " to ".join(f"({node.label}.center)" for node in self.nodes)
+        if self.cycle:
+            path_str += " -- cycle"
+        return f"\\draw{options} {path_str};\n"
+
+
+class TikzFigure:
+    def __init__(self, **kwargs):
+        """
+        Initialize the TikzFigure class for creating TikZ figures.
+
+        Parameters:
+        **kwargs: Arbitrary keyword arguments.
+            - figsize (tuple): Figure size (default is (10, 6)).
+            - caption (str): Caption for the figure.
+            - description (str): Description of the figure.
+            - label (str): Label for the figure.
+            - grid (bool): Whether to display grid lines (default is False).
+            TODO: Add all options
+        """
+        # Set default values
+        self._figsize = kwargs.get("figsize", (10, 6))
+        self._caption = kwargs.get("caption", None)
+        self._description = kwargs.get("description", None)
+        self._label = kwargs.get("label", None)
+        self._grid = kwargs.get("grid", False)
+
+        # Initialize lists to hold Node and Path objects
+        self.nodes = []
+        self.paths = []
+        self.layers = {}
+
+        # Counter for unnamed nodes
+        self._node_counter = 0
+
+    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:
+            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
+
+    def add_raw(self, raw_tikz, layer=0, **kwargs):
+        tikz = TikzWrapper(raw_tikz)
+        if layer in self.layers:
+            self.layers[layer].add(tikz)
+        else:
+            self.layers[layer] = Tikzlayer(layer)
+            self.layers[layer].add(tikz)
+        return tikz
+
+    def get_node(self, node_label):
+        for node in self.nodes:
+            if node.label == node_label:
+                return node
+
+    def get_layer(self, item):
+        for layer, layer_items in self.layers.items():
+            if item in [layer_item.label for layer_item in layer_items]:
+                return layer
+        print(f"Item {item} not found in any layer!")
+
+    def add_tabs(self, tikz_script):
+        tikz_script_new = ""
+        tab_str = "    "
+        num_tabs = 0
+        for line in tikz_script.split("\n"):
+            if "\\end" in line:
+                num_tabs = max(num_tabs - 1, 0)
+            tikz_script_new += f"{tab_str*num_tabs}{line}\n"
+            if "\\begin" in line:
+                num_tabs += 1
+        return tikz_script_new
+
+    def generate_tikz(self):
+        """
+        Generate the TikZ script for the figure.
+
+        Returns:
+        - tikz_script (str): The TikZ script as a string.
+        """
+        tikz_script = "\\begin{tikzpicture}\n"
+        tikz_script += "% Define the layers library\n"
+        layers = sorted([str(layer) for layer in self.layers.keys()])
+        for layer in layers:
+            tikz_script += f"\\pgfdeclarelayer{{{layer}}}\n"
+        tikz_script += f"\\pgfsetlayers{{{','.join(layers)}}}\n"
+
+        # Add grid if enabled
+        # TODO: Create a Grid class
+        if self._grid:
+            tikz_script += (
+                "    \\draw[step=1cm, gray, very thin] (-10,-10) grid (10,10);\n"
+            )
+        ordered_layers = []
+        buffered_layers = set()
+
+        for key, layer in self.layers.items():
+            # layer_order, buffered_layers = update_layer_order(layer, layer_order, buffered_layers)
+            reqs = layer.get_reqs()
+            if all([r == layer.label for r in reqs]):
+                ordered_layers.append(layer)
+            elif all([r in [l.label for l in ordered_layers] for r in reqs]):
+                ordered_layers.append(layer)
+            else:
+                buffered_layers.add(layer)
+
+            for buffered_layer in buffered_layers:
+                buff_reqs = buffered_layer.get_reqs()
+                if all([r in [l.label for l in ordered_layers] for r in buff_reqs]):
+                    print("Move layer from buffer")
+                    ordered_layers.append(key)
+                    buffered_layers.remove(key)
+        assert (
+            len(buffered_layers) == 0
+        ), f"Layer order is impossible for layer {[layer.label for layer in buffered_layers]}"
+        for layer in ordered_layers:
+            tikz_script += layer.generate_tikz()
+
+        tikz_script += "\\end{tikzpicture}"
+
+        # Wrap in figure environment if necessary
+        if self._caption or self._description or self._label:
+            figure_env = "\\begin{figure}\n" + tikz_script + "\n"
+            if self._caption:
+                figure_env += f"    \\caption{{{self._caption}}}\n"
+            if self._label:
+                figure_env += f"    \\label{{{self._label}}}\n"
+            figure_env += "\\end{figure}"
+            tikz_script = figure_env
+        tikz_script = self.add_tabs(tikz_script)
+        return tikz_script
+
+    def savefig(self, filepath):
+        tikz_code = self.generate_tikz()
+        with open(filepath, "w") as f:
+            f.write(tikz_code)
+
+    def generate_standalone(self):
+        tikz_code = self.generate_tikz()
+
+        # Create a minimal LaTeX document
+        latex_document = (
+            "\\documentclass[border=10pt]{standalone}\n"
+            "\\usepackage{tikz}\n"
+            "\\begin{document}\n"
+            f"{tikz_code}\n"
+            "\\end{document}"
+        )
+        return latex_document
+
+    def compile_pdf(self, filename="output.pdf"):
+        """
+        Compile the TikZ script into a PDF using pdflatex.
+
+        Parameters:
+        - filename (str): The name of the output PDF file (default is 'output.pdf').
+
+        Notes:
+        - Requires 'pdflatex' to be installed and accessible from the command line.
+        """
+        latex_document = self.generate_standalone()
+
+        # Use a temporary directory to store the LaTeX files
+        with tempfile.TemporaryDirectory() as tempdir:
+            tex_file = os.path.join(tempdir, "figure.tex")
+            with open(tex_file, "w") as f:
+                f.write(latex_document)
+
+            # Run pdflatex
+            try:
+                subprocess.run(
+                    ["pdflatex", "-interaction=nonstopmode", tex_file],
+                    cwd=tempdir,
+                    check=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+            except subprocess.CalledProcessError as e:
+                print("An error occurred while compiling the LaTeX document:")
+                print(e.stderr.decode())
+                return
+
+            # Move the output PDF to the desired location
+            pdf_output = os.path.join(tempdir, "figure.pdf")
+            if os.path.exists(pdf_output):
+                os.rename(pdf_output, filename)
+                print(f"PDF successfully compiled and saved as '{filename}'.")
+            else:
+                print("PDF compilation failed. Please check the LaTeX log for details.")
+
+    def plot_matplotlib(self, 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.
+        """
+
+        # Plot paths first so they appear behind nodes
+        for path in self.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.options.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.options.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.options.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 self.nodes:
+            # Determine shape and size
+            shape = node.options.get("shape", "circle")
+            fill_color_spec = node.options.get("fill", "white")
+            edge_color_spec = node.options.get("draw", "black")
+            linewidth = float(node.options.get("line_width", 1))
+            size = float(node.options.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 self.nodes]
+        all_y = [node.y for node in self.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")

maxplotlib/tests/test_canvas.py

@@ -0,0 +1,7 @@
+def test():
+    import maxplotlib.canvas.canvas
+    import maxplotlib.subfigure.line_plot
+
+
+if __name__ == "__main__":
+    test()

maxplotlib/tests/test_imports.py

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

maxplotlibx-0.1.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: maxplotlibx
+Version: 0.1
+Summary: A reproducible plotting module with various backends and export options.
+Author: Max
+Project-URL: Source, https://github.com/max-models/maxplotlib
+Keywords: matplotlib
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib
+Requires-Dist: pint
+Requires-Dist: plotly
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Provides-Extra: docs
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: nbsphinx; extra == "docs"
+Requires-Dist: ipykernel; extra == "docs"
+Requires-Dist: nbconvert; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: maxplotlibx[docs,test]; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: jupyterlab; extra == "dev"
+Requires-Dist: nbstripout; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pyproject-fmt; extra == "dev"
+Dynamic: license-file
+
+# maxplotlib
+
+This is a wrapper for matplotlib so I can produce figures with consistent formatting. It also has some pretty nice additions such as using layers and exporting to tikz.
+
+Related packages: [maxtikzlib](https://github.com/max-models/maxtikzlib) and [maxtexlib](https://github.com/max-models/maxtexlib).
+
+## Install
+
+Create and activate python environment
+
+```
+python -m venv env
+source env/bin/activate
+pip install --upgrade pip
+```
+
+Install the code and requirements with pip
+
+```
+pip install -e .
+```
+
+Additional dependencies for developers can be installed with
+
+```
+pip install -e ".[dev]"
+```
+
+Some examples can be found in `tutorials/`

maxplotlibx-0.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+maxplotlib/__init__.py,sha256=M4hqMJNeTsfZU99H6vI_rr8ua-ZM49GyEMHUV_Vq2JQ,66
+maxplotlib/backends/matplotlib/utils.py,sha256=fmKhWiBeWALGuHUBxTEMl0GVpRF7TObfpZWjsaL7ZOM,3585
+maxplotlib/backends/matplotlib/utils_old.py,sha256=VpkRRt3bhUtPd03SxWa7mPRWwSiOu9j5SA3GFlJ1DDc,29391
+maxplotlib/backends/plotly/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxplotlib/backends/plotly/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxplotlib/canvas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxplotlib/canvas/canvas.py,sha256=7HXQlcsWcNJzOy9T7A3PDkjYVPh3ciHKV7R8pHzTO9s,17352
+maxplotlib/colors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxplotlib/colors/colors.py,sha256=_1V2Mumh_aM0Y7iOzQOEItrCh2nzmFKapzy1OGZ-_Q0,2599
+maxplotlib/linestyle/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxplotlib/linestyle/linestyle.py,sha256=xGakDaroYVb9HWQoL5RtwPAno5SUH70r85ozXiA2U3c,2021
+maxplotlib/objects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxplotlib/objects/layer.py,sha256=BGZTtTzu20FkZyGwhnBql827HV1I7SLkKw08bDdIqeQ,556
+maxplotlib/objects/node.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxplotlib/objects/path.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxplotlib/subfigure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxplotlib/subfigure/line_plot.py,sha256=QzJL2Cx5XMAfONMWUaEV8MyTJcjnz_ovHyDAaNKydkU,10826
+maxplotlib/subfigure/subfigure.py,sha256=MMIAT8haC-zuCLucXagWchHqBYQdqWLc_MJv5G1OAP0,80
+maxplotlib/subfigure/tikz_figure.py,sha256=xzil9gBOsT6JMPcskS07yiYSwahMvGHVs41vtkZCU7U,16822
+maxplotlib/tests/test_canvas.py,sha256=-wbfUUnfXF4AGe2UPZl0_QuDDYKEdV9378UZo1MWC84,130
+maxplotlib/tests/test_imports.py,sha256=icFvgf2VVlO5e5FkU-IFYk6CPnXQWGM3_nJyEkpC2_Y,172
+maxplotlib/tests/test_plot.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxplotlibx-0.1.dist-info/licenses/LICENSE,sha256=yQ4Pipqp0gP6uNf8Hb6bj4HpyUuJvg41pkIrx3vUoxY,1060
+maxplotlibx-0.1.dist-info/METADATA,sha256=3MjFktiWokVySS9MEFpxC4gURJ2uAUsempgSra_Hwl8,1838
+maxplotlibx-0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maxplotlibx-0.1.dist-info/top_level.txt,sha256=F_tiI1wDrGUZQgHR8EKZ-ajO0SSTSTp-NmYbGm1A_kA,11
+maxplotlibx-0.1.dist-info/RECORD,,

maxplotlibx-0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

maxplotlibx-0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Max
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

maxplotlibx-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+maxplotlib