tikzplot42 0.4.3__tar.gz → 0.4.6__tar.gz

{tikzplot42-0.4.3/src/tikzplot42.egg-info → tikzplot42-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplot42
-Version: 0.4.3
+Version: 0.4.6
 Summary: TikzPlot to make TikZ/PGFPlots plots with matplotlib.pyplot-like syntax.
 Author-email: Zan Ambrozic <zan.ambrozic7@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{tikzplot42-0.4.3 → tikzplot42-0.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tikzplot42"
-version = "0.4.3"
+version = "0.4.6"
 description = "TikzPlot to make TikZ/PGFPlots plots with matplotlib.pyplot-like syntax."
 authors = [
     { name = "Zan Ambrozic", email = "zan.ambrozic7@gmail.com" }

{tikzplot42-0.4.3 → tikzplot42-0.4.6}/src/tikzplot/axes.py

@@ -1,3 +1,6 @@
+from typing import Any
+from xml.dom import XMLNS_NAMESPACE
+
 import numpy as _np
 import matplotlib.pyplot as _plt
 
@@ -7,6 +10,7 @@ from .config import TikzConfig
 from .colorbar import Colorbar
 from .state import _next_imshow_num, main_name
 from .latex_special import tex_text
+from .colors import _tex_color
 
 class BaseAxes:
     def __init__(self):
@@ -22,17 +26,20 @@ class BaseAxes:
             self._axis_args.add(f"/pgf/number format/.cd, 1000 sep={{{TikzConfig.THOUSANDS_SEP}}}")
 
         self._add_legend = []
+        self._legend_lab_col: Any = None
         self._coordinates = {}
         self._cmap_bar = None
 
         self._ext_ymin = False
         self._ext_ymax = False
 
-    def _plot(self, x, y, settings=[], xerr=None, yerr=None, **style):
+        self._reverse_elements = []
+
+    def _plot(self, x, y, settings={}, xerr=None, yerr=None, **style):
         if isinstance(self, Axes) and self._polar:
             x = _np.rad2deg(x)
         e = Graph(self, (x, y), settings, xerr=xerr, yerr=yerr, **style)
-        if TikzConfig.USE_GROUPPLOTS and ("axvspan" == settings or "axhspan" == settings):
+        if TikzConfig.USE_GROUPPLOTS and ("axvspan" in settings or "axhspan" in settings):
             self._elements.insert(0, e)
         else:
             self._elements.append(e)
@@ -88,7 +95,7 @@ class BaseAxes:
                         self._cmap_bar = kwargs["cmap"]
         except: pass
         
-        return self._plot(x, y, **kwargs, ls="", settings=["scatter"])
+        return self._plot(x, y, **kwargs, ls="", settings={"scatter": None})
                         
     def semilogy(self, x, y, *args, **kwargs):
         kws = {"fmt", "base", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "marker", "markersize", "ms", "label"}
@@ -126,12 +133,12 @@ class BaseAxes:
             if o == "horizontal":
                 vert = False
         if vert:
-            return self._plot(x,y,settings=["ycomb"], **kwargs)
+            return self._plot(x,y,settings={"ycomb": None}, **kwargs)
         else:
-            return self._plot(y,x,settings=["xcomb"], **kwargs)
+            return self._plot(y,x,settings={"xcomb": None}, **kwargs)
 
     def fill_between(self, x, y1, y2=None, **kwargs):
-        kws = {"fmt", "alpha", "color", "c", "label"}
+        kws = {"fmt", "alpha", "color", "c", "label", "hatch", "hatch_color", "hatch_linewidth", "hatch_distance"}
         kwargs = self._check_kwargs("fill_between", kws, **kwargs)
         def _check_instance(xs, ys, pname):
             for el in self._elements:
@@ -166,7 +173,7 @@ class BaseAxes:
                 self._plot(xs,ys,path_name=name2, alpha=0)
             else:
                 name2 = inst
-        e = Graph(self, f"fill between [of={name1} and {name2}]",settings=[], xerr=None, yerr=None, **kwargs)
+        e = Graph(self, f"fill between [of={name1} and {name2}]",settings={}, xerr=None, yerr=None, **kwargs)
         self._elements.append(e)
         return e
         
@@ -215,41 +222,155 @@ class BaseAxes:
                 self._plot([xs[i]]*2, [ymins[i], ymaxs[i]], None, None, None, c=colorss[i], ls=lss[i])
 
     def hist(self, x, bins=10, density=False,**kwargs):
-        #kws = {"alpha", "color", "c", "label"}
-        #kwargs = self._check_kwargs("hist", kws, **kwargs)
-        try:
-            iter(x)
-            iter(x[0])
-            datasets = x
-        except:
-            datasets = [x]
+        kws = {"alpha", "color", "c", "label", "facecolor", "fc", "edgecolor", "ec", "orientation", "rwidth", "cumulative", "range", "histtype", "weights", "cumulative", "align", "stacked", "fill", "hatch", "hatch_color", "hatch_linewidth", "hatch_distance"}
+        kwargs = self._check_kwargs("hist", kws, **kwargs)
+        if isinstance(x, (list, tuple)) and len(x) > 0 and isinstance(x[0], (list, tuple, _np.ndarray)):
+            try:
+                datasets = [_np.asarray(ds, dtype=_np.float64) for ds in x]
+                if any(ds.ndim != 1 for ds in datasets):
+                    raise ValueError("Nested datasets must all be 1-dimensional.")
+            except (ValueError, TypeError):
+                x_arr = _np.asarray(x)
+                if x_arr.ndim == 2:
+                    datasets = [x_arr[:, i] for i in range(x_arr.shape[1])]
+                else:
+                    raise ValueError("Invalid dataset structure.")
+        else:
+            x_arr = _np.asarray(x)
+            if x_arr.ndim == 1:
+                datasets = [x_arr]
+            elif x_arr.ndim == 2:
+                datasets = [x_arr[:, i] for i in range(x_arr.shape[1])]
+            else:
+                raise ValueError(f"Input must be 1D or 2D, got {x_arr.ndim}D.")
+
+        stack = kwargs.pop("stacked", False)
+        datas = {}
+        for kw in ["color", "c", "facecolor", "fc", "edgecolor", "ec", "label", "hatch", "hatch_color", "hatch_linewidth", "hatch_distance"]:
+            if kw in kwargs:
+                if isinstance(kwargs[kw], (list)):
+                    if len(kwargs[kw]) != len(datasets):
+                        raise Warning(f"Length of {kw} does not match number of datasets.")
+                    prop = kwargs.pop(kw)
+                else:
+                    prop = [kwargs.pop(kw)] * len(datasets)
+                for i in range(len(datasets)):
+                    if i not in datas:
+                        datas[i] = {}
+                    datas[i][kw] = prop[i]
         all_data = _np.concatenate(datasets)
-        edges = _np.histogram_bin_edges(all_data, bins=bins)
+        edges = _np.histogram_bin_edges(all_data, bins=bins, weights=kwargs.get("weights", None), range=kwargs.get("range", None))
         widths = edges[1:] - edges[:-1]
-        settings = []
+        offset = 0
+        settings = {}
+        hist_type = kwargs.pop("histtype", "bar")
+        if hist_type not in ["bar", "barstacked", "step", "stepfilled"]:
+            raise Warning(f"Invalid histtype: {hist_type}.")
         if "orientation" in kwargs and kwargs["orientation"] == "horizontal":
-            settings.append("xbar")
+            settings["xbar"] = None
         else:
-            settings.append("ybar")
-        settings.append("fill")
-        if "rwidth" in kwargs:
-            settings.append(f"bar width={widths.mean()*kwargs['rwidth']}")
+            settings["ybar"] = None
+        if ("rwidth" in kwargs or (len(datasets) > 1 and not stack)) and isinstance(bins, int):
+            if stack or len(datasets) == 1:
+                settings["bar width"] = f"{widths.mean()*kwargs['rwidth']}"
+            else:
+                if "rwidth" in kwargs:
+                    settings["bar width"] = f"{widths.mean()*kwargs['rwidth']/(len(datasets)+1)}"
+                    offset = widths.mean() * kwargs['rwidth'] / (len(datasets) + 1)
+                else:
+                    settings["bar width"] = f"{widths.mean()/(len(datasets)+1)}"
+                    offset = widths.mean() / (len(datasets) + 1)
         else:
-            settings[0] += " interval"
+            if "xbar" in settings:
+                settings.pop("xbar")
+                settings["xbar interval"] = None
+            elif "ybar" in settings:
+                settings.pop("ybar")
+                settings["ybar interval"] = None
         if "range" in kwargs:
-            if settings[0] == "xbar":
+            if "xbar" in settings:
                 self.set_ylim(kwargs["range"])
             elif isinstance(self, Axes):
                 self.set_xlim(kwargs["range"])
             elif  isinstance(self, Secondary):
                 self._primary.set_xlim(kwargs["range"])
+        base_settings = settings.copy()
         outputs = []
-        for data in datasets:
-            counts, _ = _np.histogram(data, edges, density=density)
-            centers = (edges[:-1] + edges[1:]) / 2
+        old_counts = _np.zeros(len(edges), dtype=_np.float64)
+        totals, _ = _np.histogram(all_data, edges, density=False, weights=kwargs.get("weights", None), range=kwargs.get("range", None))
+        tot_sum = totals.sum()
+        align_offset = 0
+        if "align" in kwargs:
+            if kwargs["align"] not in ["left", "mid", "right"]:
+                raise Warning(f"Invalid align value: {kwargs['align']}. Must be 'left', 'mid', or 'right'.")
+            if kwargs["align"] == "left":
+                align_offset = -widths.mean()/2
+            elif kwargs["align"] == "mid":
+                align_offset = 0
+            elif kwargs["align"] == "right":
+                align_offset = widths.mean()/2
+        for i in range(len(datasets)):
+            data = datasets[i]
+            settings = base_settings.copy()
+            kws = datas.get(i, {})
+            if "label" in kws:
+                if "xbar" in settings:
+                    settings["xbar legend"] = None
+                elif "xbar interval" in settings:
+                    settings["xbar interval legend"] = None
+                elif "ybar" in settings:
+                    settings["ybar legend"] = None
+                else:
+                    settings["ybar interval legend"] = None
+            fill = kws.pop("facecolor", kws.pop("fc", kws.pop("color", kws.pop("c", None))))
+            draw = kws.pop("edgecolor", kws.pop("ec", None))
+            if fill:
+                fill = self._match_color(fill)
+            settings["fill"] = fill
+            if draw and hist_type != "stepfilled":
+                draw = self._match_color(draw)
+                settings["draw"] = draw
+            else:
+                settings["draw"] = "none"
+            counts, _ = _np.histogram(data, edges, density=density, weights=kwargs.get("weights", None), range=kwargs.get("range", None))
+            if "xbar interval" in settings or "ybar interval" in settings: # edges for interval
+                if "rwidth" in kwargs:
+                    xs = [edges[0] + widths[0]*(1-kwargs["rwidth"])/2]
+                    new_counts = []
+                    for j in range(len(widths)):
+                        xs.append(xs[-1] + widths[j]*kwargs["rwidth"])
+                        new_counts.append(counts[j])
+                        if j < len(counts)-1:
+                            xs.append(xs[-1] + (widths[j] + widths[j+1])*(1-kwargs["rwidth"])/2)
+                            new_counts.append(0)
+                    counts = new_counts + [0]
+                else:
+                    xs = edges
+                    counts = _np.concatenate([counts, [0]])
+            else: # centers
+                xs = (edges[:-1] + edges[1:]) / 2
+                if offset > 0:
+                    settings["bar shift"] = f"{offset*(i - len(datasets)/2 + 0.5)}"
+            xs = xs + align_offset * _np.ones_like(xs)
             if "cumulative" in kwargs and kwargs["cumulative"]:
                 counts = _np.cumsum(counts)
-            outputs.append(self._plot(centers, counts, settings=settings, **kwargs))
+            if stack:
+                if density:
+                    set_counts, _ = _np.histogram(data, edges, density=False, weights=kwargs.get("weights", None), range=kwargs.get("range", None))
+                    counts = counts * _np.sum(set_counts) / tot_sum
+                counts = _np.asarray(counts, dtype=_np.float64)
+                counts += old_counts
+                old_counts = counts.copy()
+            if hist_type == "step":
+                    kwargs.pop("facecolor", None)
+                    kwargs.pop("fc", None)
+                    kwargs.pop("fill", None)
+                    self.step([edges[0]] + list(edges), [0] + list(counts), where="pre", **kws)
+            else:
+                e = self._plot(xs, counts, settings=settings, **kws)
+                outputs.append(e)
+        if outputs and stack:
+            self._reverse_elements.append([id(e) for e in outputs])
         return outputs
     
     def step(self, x, y, *args, **kwargs):
@@ -257,7 +378,7 @@ class BaseAxes:
         kwargs = self._check_kwargs("step", kws, **kwargs)
         WHERE_DICT = {"pre": "left", "post": "right", "mid": "mid"}
         where = WHERE_DICT.get(kwargs.pop("where", "pre"), None)
-        settings = [f"const plot mark {where}"]
+        settings = {f"const plot mark {where}": None}
         if len(args) == 1:
             kwargs["fmt"] = args[0]
         return self._plot(x,y,settings=settings, **kwargs)
@@ -266,7 +387,7 @@ class BaseAxes:
         kws = {"fmt", "base", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "label"}
         kwargs = self._check_kwargs("axvline", kws, **kwargs)
         self._ext_ymin = self._ext_ymax = True
-        self._plot(x, (ymin, ymax), settings="axvline", **kwargs)
+        self._plot(x, (ymin, ymax), settings={"axvline": None}, **kwargs)
 
     def axhline(self, y, xmin=0, xmax=1, **kwargs):
         kws = {"fmt", "base", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "label"}
@@ -275,18 +396,18 @@ class BaseAxes:
             self._primary._ext_xmin = self._primary._ext_xmax = True
         else:
             self._ext_xmin = self._ext_xmax = True
-        self._plot((xmin, xmax), y, settings="axhline", **kwargs)
+        self._plot((xmin, xmax), y, settings={"axhline": None}, **kwargs)
 
     def axvspan(self, xmin, xmax, ymin=0, ymax=1, **kwargs):
-        kws = {"c", "color", "alpha", "label"}
+        kws = {"c", "color", "alpha", "label", "hatch", "hatch_color", "hatch_linewidth", "hatch_distance"}
         kwargs = self._check_kwargs("axvspan", kws, **kwargs)
         self._ext_ymin = self._ext_ymax = True
         if TikzConfig.USE_GROUPPLOTS:
             self._axis_args.add("set layers")
-        self._plot([xmin, xmax], [ymin, ymax], settings="axvspan", **kwargs)
+        self._plot([xmin, xmax], [ymin, ymax], settings={"axvspan": None}, **kwargs)
 
     def axhspan(self, ymin, ymax, xmin=0, xmax=1, **kwargs):
-        kws = {"c", "color", "alpha", "label"}
+        kws = {"c", "color", "alpha", "label", "hatch", "hatch_color", "hatch_linewidth", "hatch_distance"}
         kwargs = self._check_kwargs("axhspan", kws, **kwargs)
         if isinstance(self, Secondary):
             self._primary._ext_xmin = self._primary._ext_xmax = True
@@ -294,7 +415,7 @@ class BaseAxes:
             self._ext_xmin = self._ext_xmax = True
         if TikzConfig.USE_GROUPPLOTS:
             self._axis_args.add("set layers")
-        self._plot([xmin, xmax], [ymin, ymax], settings="axhspan", **kwargs)
+        self._plot([xmin, xmax], [ymin, ymax], settings={"axhspan": None}, **kwargs)
 
     def set_ylabel(self, label):
         self._axis_options["ylabel"] = f"{{{tex_text(label)}}}"
@@ -354,7 +475,19 @@ class BaseAxes:
     _LEGEND_LOC_MAP = ["best", "upper right", "upper left", "lower_left", "lower right", "right", "center left", "center right", "lower center", "upper center", "center"]
     _ANCHOR_MAP = {"top": "north", "bottom": "south", "upper": "north", "lower": "south", "left": "west", "right": "east", "center": "center"}
 
+    def _match_color(self, input):
+        if isinstance(self, Axes) or isinstance(self, Secondary):
+            if input == "none":
+                return "none"
+            ccode, op = _tex_color(input, self._style)
+            if isinstance(ccode, str):
+                return ccode
+            r,g,b = ccode
+            self._add_col(r,g,b)
+            return f"c{r:.3f}{g:.3f}{b:.3f}".replace(".", "")
+
     def legend(self, *args, **kwargs):
+        legend_string = {}
         if "loc" in kwargs:
             loc = kwargs["loc"]
             lx = ly = posit = None
@@ -381,20 +514,34 @@ class BaseAxes:
                 elif "east" in posit:
                     lx = 1 - TikzConfig.LEGEND_REL_X
 
-            legend_string = []
             if lx is not None and ly is not None:
-                legend_string.append(r"at={(" + f"{lx},{ly}" + r")}")
+                legend_string["at"] = "{(" + f"{lx},{ly}" + r")}"
             if posit is not None and len(posit):
-                legend_string.append(r"anchor=" + posit)
-            if "legend style" in self._axis_options:
-                self._axis_options["legend style"] = self._axis_options["legend style"].rstrip("}") + f" ,{','.join(legend_string)}}}"
-            else:
-                self._axis_options["legend style"] = f"{{{','.join(legend_string)}}}"
+                legend_string["anchor"] = posit
+
+        if "facecolor" in kwargs and (isinstance(self, Axes) or isinstance(self, Secondary)):
+            ccode = self._match_color(kwargs["facecolor"])
+            if ccode is not None:
+                legend_string["fill"] = ccode
+        if "edgecolor" in kwargs and (isinstance(self, Axes) or isinstance(self, Secondary)):
+            ccode = self._match_color(kwargs["edgecolor"])
+            if ccode is not None:
+                legend_string["draw"] = ccode
+        if "labelcolor" in kwargs and (isinstance(self, Axes) or isinstance(self, Secondary)):
+            ccode = self._match_color(kwargs["labelcolor"])
+            if ccode is not None:
+                self._legend_lab_col = ccode
+        if "frameon" in kwargs and not kwargs["frameon"]:
+            legend_string["draw"] = "none"                      
+        if "legend style" in self._axis_options:
+            self._axis_options["legend style"].update(legend_string)
+        else:
+            self._axis_options["legend style"] = legend_string
         self._legend_on = True
         if "ncols" in kwargs:
             self._axis_options["legend columns"] = kwargs["ncols"]
         if len(args) == 2:
-            self._add_legend = args
+            self._add_legend = list(args)
         elif len(args) == 1:
             labs = args[0]
             if len(labs) > len(self._elements):
@@ -433,16 +580,36 @@ class BaseAxes:
             return ""
         for i in range(len(axs)):
             output += f"\n\\addlegendimage{{{axs[i]._style_string()}}}"
-            output += f"\n\\addlegendentry{{{tex_text(labs[i])}}}"
+            if self._legend_lab_col:
+                output += f"\n\\addlegendentry[{self._legend_lab_col}]{{{tex_text(labs[i])}}}"
+            else:
+                output += f"\n\\addlegendentry{{{tex_text(labs[i])}}}"
         return output
         
     def _content_tex(self, filename):
-        ouptut = "\n".join(e._to_tex(filename) for e in self._elements)
-        ouptut += self._add_legend_entries()
+        element_strings = {id(e): e._to_tex(filename, self._legend_lab_col) for e in self._elements}
+        seq_map = {seq[0]: seq for seq in self._reverse_elements}
+        output_list = []
+        visited = set()
+        for e in self._elements:
+            e_id = id(e)
+            if e_id in visited:
+                continue
+            if e_id in seq_map:
+                seq = seq_map[e_id]
+                for el in reversed(seq):
+                    output_list.append(element_strings[el])
+                    visited.add(el)
+            else:
+                output_list.append(element_strings[e_id])
+                visited.add(e_id)
+
+        output = "\n".join(output_list)
+        output += self._add_legend_entries()
         for coord in self._coordinates:
             x,y = self._coordinates[coord]
-            ouptut += f"\n\\coordinate ({coord}) at ({x},{y});"
-        return ouptut
+            output += f"\n\\coordinate ({coord}) at ({x},{y});"
+        return output
     
     def _get_hard_range(self,which):
         arg = f"{which[0]}mode"
@@ -519,6 +686,10 @@ class BaseAxes:
             if attr in kwargs:
                 defined[attr](kwargs.pop(attr))
 
+    def _reoreder_last_elements(self, n):
+        if n <= 0: return
+        self._elements = self._elements[:-n] + self._elements[:-n-1:-1]
+
 class Axes(BaseAxes):
 
     def __init__(self, nrows, ncols, index, fig, polar):
@@ -654,7 +825,7 @@ class Axes(BaseAxes):
         if kwargs:
             accepted_kwargs = {"color", "c", "linestyle", "ls", "linewidth", "lw", "alpha"}
             kwargs = self._check_kwargs("grid", accepted_kwargs, **kwargs)
-            g = Graph(self, None, [], None, None, **kwargs)._style_string()
+            g = Graph(self, None, {}, None, None, **kwargs)._style_string()
             self._axis_options[f"{selector}grid style"] = f"{{{g}}}"
             
     def set_minorticks_num(self, num):
@@ -733,7 +904,7 @@ class Axes(BaseAxes):
         _plt.axis("off")
         _plt.imshow(*args, **kwargs)
         im_name = f"{str(main_name()[1]).removesuffix('.py')}_{TikzConfig.IMSHOW_SAVENAME}{_next_imshow_num()}.pdf"
-        _plt.savefig(im_name,bbox_inches='tight', pad_inches=0)
+        _plt.savefig(im_name, bbox_inches='tight', pad_inches=0)
         return im_name
 
     def _axis_option_string(self):
@@ -754,7 +925,7 @@ class Axes(BaseAxes):
             if "extent" in self._imshow[1]:
                 bounds = self._imshow[1]["extent"]
             xm, xM, ym, yM = bounds
-            self._elements.insert(0, Graph(self, f"graphics [xmin={xm}, xmax={xM}, ymin={ym}, ymax={yM}] {{{im_name}}}",settings=[], xerr=None, yerr=None, onlayer="axis background"))
+            self._elements.insert(0, Graph(self, f"graphics [xmin={xm}, xmax={xM}, ymin={ym}, ymax={yM}] {{{im_name}}}", settings={}, xerr=None, yerr=None, onlayer="axis background"))
         axis_opt_str = ""
         if self._axis_args:
             axis_opt_str += ",\n".join(self._axis_args)
@@ -787,7 +958,13 @@ class Axes(BaseAxes):
                 self._axis_options["ymax"] = self._fig._next_limname("ymax", self._axis_options.get("ymax", yM))
         if self._axis_options:
             if axis_opt_str: axis_opt_str += ",\n"
-            axis_opt_str += ",\n".join(f"{k}={v}" for k, v in self._axis_options.items())
+            for k, v in self._axis_options.items():
+                if isinstance(v, dict):
+                    axis_opt_str += f"{k}={{"
+                    axis_opt_str += ",\n".join(f"{kk}={vv}" for kk, vv in v.items())
+                    axis_opt_str += "},\n"
+                else:
+                    axis_opt_str += f"{k}={v},\n"
         if self._colorbar:
             axis_opt_str += self._colorbar
         elif self._cmap_bar:
@@ -859,6 +1036,15 @@ class Axes(BaseAxes):
                 defined[attr](kwargs.pop(attr))
 
         super().set(**kwargs)
+
+    def set_facecolor(self, color):
+        ccode, _ = _tex_color(color, self._style)
+        if isinstance(ccode, str):
+            self._axis_options["axis background/.style"] = f"{{fill={ccode}}}"
+        else:
+            r,g,b = ccode
+            self._add_col(r,g,b)
+            self._axis_options["axis background/.style"] = f"{{fill=c{r:.3f}{g:.3f}{b:.3f}}}".replace(".", "")
     
 class Secondary(BaseAxes):
     def __init__(self, primary):
@@ -900,7 +1086,13 @@ class Secondary(BaseAxes):
         self._axis_options["xmax"] = self._primary._axis_options["xmax"]
         if self._axis_options:
             if axis_opt_str: axis_opt_str += ",\n"
-            axis_opt_str += ",\n".join(f"{k}={v}" for k, v in self._axis_options.items())
+            for k, v in self._axis_options.items():
+                if isinstance(v, dict):
+                    axis_opt_str += f"{k}={{"
+                    axis_opt_str += ",\n".join(f"{kk}={vv}" for kk, vv in v.items())
+                    axis_opt_str += "},\n"
+                else:
+                    axis_opt_str += f"{k}={v},\n"
         return axis_opt_str
     
     def _padding(self):