tikzplot42 0.4.3__tar.gz → 0.4.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplot42
-Version: 0.4.3
+Version: 0.4.5
 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.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tikzplot42"
-version = "0.4.3"
+version = "0.4.5"
 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.5}/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,9 +133,9 @@ 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"}
@@ -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,142 @@ 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"}
+        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"]:
+            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()
+        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 or "xbar interval" in settings:
+                    settings["xbar legend"] = None
+                else:
+                    settings["ybar legend"] = None
+            else:
+                settings["forget plot"] = 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)):  # Changed 'i' to 'j' to avoid overwriting dataset index 'i'
+                        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)}"
             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 +365,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 +374,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,7 +383,7 @@ 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"}
@@ -283,7 +391,7 @@ class BaseAxes:
         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"}
@@ -294,7 +402,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 +462,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 +501,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 +567,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 +673,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 +812,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 +891,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 +912,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 +945,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 +1023,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 +1073,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):

{tikzplot42-0.4.3 → tikzplot42-0.4.5}/src/tikzplot/axes.pyi

@@ -1,6 +1,5 @@
 from typing import Any, Optional, Sequence, Tuple, Union, Literal
 import numpy as np
-from pyrsistent import T
 from .colorbar import Colorbar
 
 ArrayLike = Union[Sequence[float], np.ndarray]
@@ -277,15 +276,24 @@ class BaseAxes:
     def hist(
         self,
         x: Union[ArrayLike, Sequence[ArrayLike]],
-        bins: int = ...,
-        density: bool = ...,
+        bins: int | Sequence[float] = 10,
         *,
-        cumulative: bool = ...,
+        weight: ArrayLike | None = None,
+        density: bool = False,
+        cumulative: bool = False,
+        histtype: Literal["bar", "barstacked", "step", "stepfilled"] = "bar",
         orientation: Literal["horizontal","vertical"] = "vertical",
-        rwidth: Optional[float] = ...,
-        range: Optional[Tuple[float,float]] = ...,
-        color: Optional[ColorLike] = ...,
-        **kwargs: Any
+        rwidth: float | None = None,
+        range: Tuple[float,float] | None = None,
+        color: ColorLike = ...,
+        facecolor: ColorLike = ...,
+        fc: ColorLike = ...,
+        edgecolor: ColorLike = ...,
+        ec: ColorLike = ...,
+        align: Literal["left", "mid", "right"] = ...,
+        stacked: bool = False,
+        fill: bool = True,
+        #**kwargs: Any
     ) -> None: 
         """
         Draw histogram to the selected axis.
@@ -482,7 +490,7 @@ class BaseAxes:
         Set y-axis tick labels.
         """
         ...
-    def legend(self, *args: Any, loc: Optional[Union[int,str,Tuple[float,float]]] = ...) -> None:
+    def legend(self, *args: Any, loc: Optional[Union[int,str,Tuple[float,float]]] = ..., facecolor: Optional[ColorLike] = ..., edgecolor: Optional[ColorLike] = ..., labelcolor: Optional[ColorLike] = ..., frameon: Optional[bool] = ...) -> None:
         """
         Show legend for the selected axis. Despite arguments requires at least one plotted element on the axis (not necesarily with label) to show up (LaTeX does not allow legend on empty axis).
 
@@ -510,7 +518,7 @@ class BaseAxes:
     def _get_limit(self, which: Literal["xmin","xmax","ymin","ymax"]) -> Tuple[float,bool,str]: ...
     def _set_range(self, which: Literal["xmin","xmax","ymin","ymax"], value: Union[float, int]): ...
     def _num_points(self) -> list[int]: ...
-    # def _add_color(self, ?) -> None: ...
+    def _add_col(self, r: float, g: float, b: float) -> None: ...
     
 class Axes(BaseAxes):
     def __init__(self, nrows: int, ncols: int, index: int, fig: Any, pol: bool) -> None: ...
@@ -663,6 +671,16 @@ class Axes(BaseAxes):
         Initialize secondary y-axis.
         """
         ...
+    def set_facecolor(self, color: ColorLike) -> None:
+        """
+        Set axis background color.
+
+        Parameters
+        ----------
+        color: all matplotlib color formats (without X11/xkcd)
+            Background color of axis: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+        """
+        ...
     def _export_imshow(self, *args: Any, **kwargs: Any) -> str: ...
     def _axis_options_string(self) -> str: ...
     def _margins(self) -> tuple[float, float, float, float]: ...

{tikzplot42-0.4.3 → tikzplot42-0.4.5}/src/tikzplot/axes3d.py

@@ -74,7 +74,7 @@ class Axes3:
         if _add_settgs is not None:
             self._axis_options = _add_settgs | self._axis_options
 
-    def _plot(self, xs, ys, zs, zdir="z", settings=[], xerr=None, yerr=None, zerr=None, **style):
+    def _plot(self, xs, ys, zs, zdir="z", settings={}, xerr=None, yerr=None, zerr=None, **style):
         if isinstance(zs, (float,int)):
             zs = [zs] * len(xs)
         if zdir == "y":
@@ -110,12 +110,12 @@ class Axes3:
     def plot_surface(self, X, Y, Z, **kwargs):
         kws = {"alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "label"}
         kwargs = self._check_kwargs("plot", kws, **kwargs)
-        return self._plot(X, Y, Z, settings=["surf",  f"mesh/rows={X.shape[0]}"] , **kwargs)
+        return self._plot(X, Y, Z, settings={"surf": None,  "mesh/rows": X.shape[0]} , **kwargs)
     
     def plot_wireframe(self, X, Y, Z, **kwargs):
         kws = {"alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "label"}
         kwargs = self._check_kwargs("plot", kws, **kwargs)
-        return self._plot(X, Y, Z, settings=["mesh",  f"mesh/rows={X.shape[0]}"] , **kwargs)
+        return self._plot(X, Y, Z, settings={"mesh": None,  "mesh/rows": X.shape[0]} , **kwargs)
 
     def errorbar(self, x, y, z, zerr=None, yerr=None, xerr=None, **kwargs):
         kws = {"fmt", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "marker", "markersize", "ms", "label"}
@@ -171,7 +171,7 @@ class Axes3:
                 self._plot(xs,ys,path_name=name2, alpha=0)
             else:
                 name2 = inst"""
-        e = Graph3(self, f"fill between [of={name1} and {name2}]",settings=[], xerr=None, yerr=None, zerr=None, **kwargs)
+        e = Graph3(self, f"fill between [of={name1} and {name2}]",settings={}, xerr=None, yerr=None, zerr=None, **kwargs)
         self._elements.append(e)
         return e