tikzplot42 0.3.4__tar.gz → 0.3.7__tar.gz

{tikzplot42-0.3.4 → tikzplot42-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplot42
-Version: 0.3.4
+Version: 0.3.7
 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
@@ -737,12 +737,15 @@ Some basic plot commands are already implemented with commonly used arguments:
 - `semilogx()/semilogy()`,
 - `errorbar()`,
 - `stem()`,
-- `fill-between()`,
+- `fill_between()`,
 - `hlines()/vlines()`,
-- `historgam()`,
+- `histogram()`,
 - `step()`,
 - `imshow()`,
-- `text()`.
+- `text()`,
+- `magnify()` (used to magnify part of a plot, but Tikz cannot handle `fill_between` if this one is used, which is a long known issue),
+- `axvline()/axhline()`,
+- `axvspan()/axhspan()` (background span).
 
 #### Figures
 - `plt.figure()` (currently only to give you figure object or to set `figsize`),
@@ -775,7 +778,8 @@ If axes and plot have different name for command with same effect, both are impl
 #### Colorbars
 Colorbars and colormaps are implemented a bit differently than in matplotlib (simplified):
 - if you use `imshow()`, you may use its return in `Colorbar()` (which you have to import as `from tikzplot import Colorbar`),
-- you may use `Colorbar(axis, cmap, lower, upper, ...)` for manual colorbar. Additional kwargs may also be used by `imshow()` return.
+- you may use `Colorbar(axis, cmap, lower, upper, ...)` for manual colorbar. Additional kwargs may also be used by `imshow()` return,
+- note that only one colorbar/colormap per axis is allowed (also if you use `scatter` with colormap/colorbar).
 
 #### TikzConfig
 For plot configurations (default sizes, paddings, etc.), use `from tikzplot import TikzConfig`:

{tikzplot42-0.3.4 → tikzplot42-0.3.7}/README.md

@@ -35,12 +35,15 @@ Some basic plot commands are already implemented with commonly used arguments:
 - `semilogx()/semilogy()`,
 - `errorbar()`,
 - `stem()`,
-- `fill-between()`,
+- `fill_between()`,
 - `hlines()/vlines()`,
-- `historgam()`,
+- `histogram()`,
 - `step()`,
 - `imshow()`,
-- `text()`.
+- `text()`,
+- `magnify()` (used to magnify part of a plot, but Tikz cannot handle `fill_between` if this one is used, which is a long known issue),
+- `axvline()/axhline()`,
+- `axvspan()/axhspan()` (background span).
 
 #### Figures
 - `plt.figure()` (currently only to give you figure object or to set `figsize`),
@@ -73,7 +76,8 @@ If axes and plot have different name for command with same effect, both are impl
 #### Colorbars
 Colorbars and colormaps are implemented a bit differently than in matplotlib (simplified):
 - if you use `imshow()`, you may use its return in `Colorbar()` (which you have to import as `from tikzplot import Colorbar`),
-- you may use `Colorbar(axis, cmap, lower, upper, ...)` for manual colorbar. Additional kwargs may also be used by `imshow()` return.
+- you may use `Colorbar(axis, cmap, lower, upper, ...)` for manual colorbar. Additional kwargs may also be used by `imshow()` return,
+- note that only one colorbar/colormap per axis is allowed (also if you use `scatter` with colormap/colorbar).
 
 #### TikzConfig
 For plot configurations (default sizes, paddings, etc.), use `from tikzplot import TikzConfig`:

{tikzplot42-0.3.4 → tikzplot42-0.3.7}/pyproject.toml

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

{tikzplot42-0.3.4 → tikzplot42-0.3.7}/src/tikzplot/axes.py

@@ -17,15 +17,25 @@ class BaseAxes:
         self._yticks = True
         self._fig = None
         if TikzConfig.USE_DECIMAL_COMMA:
-            self._axis_args.add("/pgf/number format/use comma")
+            self._axis_args.add(f"/pgf/number format/.cd, use comma, 1000 sep={{{TikzConfig.THOUSANDS_SEP}}}")
+        else:
+            self._axis_args.add(f"/pgf/number format/.cd, 1000 sep={{{TikzConfig.THOUSANDS_SEP}}}")
 
         self._add_legend = ""
+        self._coordinates = {}
+        self._cmap_bar = None
+
+        self._ext_ymin = False
+        self._ext_ymax = False
 
     def _plot(self, x, y, settings=None, xerr=None, yerr=None, **style):
         if not isinstance(self, Secondary) and self._polar:
             x = _np.rad2deg(x)
         e = Graph(self, (x, y), settings, xerr=xerr, yerr=yerr, **style)
-        self._elements.append(e)
+        if TikzConfig.USE_GROUPPLOTS and ("axvspan" == settings or "axhspan" == settings):
+            self._elements.insert(0, e)
+        else:
+            self._elements.append(e)
         return e
 
     def _check_kwargs(self, func, allowed, **kwargs):
@@ -71,6 +81,10 @@ class BaseAxes:
                             vmin = kwargs.pop("vmin", min(c))
                             vmax = kwargs.pop("vmax", max(c))
                             kwargs["cmap"] = Colorbar(cmap=cmap, lower=vmin, upper=vmax)
+                    if self._cmap_bar and self._cmap_bar != kwargs["cmap"]:
+                        raise Warning("Multiple colormaps on same axis! Only one per axis is allowed.")
+                    else:
+                        self._cmap_bar = kwargs["cmap"]
         except: pass
         
         return self._plot(x, y, **kwargs, ls="", settings=["scatter"])
@@ -176,6 +190,28 @@ class BaseAxes:
                 return self._plot([xmins[i], xmaxs[i]], [ys[i]]*2, None, None, None, c=colorss[i], ls=lss[i], label=kwargs["label"])
             else:
                 return self._plot([xmins[i], xmaxs[i]], [ys[i]]*2, None, None, None, c=colorss[i], ls=lss[i])
+            
+    def vlines(self, x, ymin, ymax, colors="k", linestyles="solid", **kwargs):
+        kws = {"label"}
+        kwargs = self._check_kwargs("vlines", kws, **kwargs)
+        def _pad_or_truncate(some_list, target_len):
+            return some_list[:target_len] + [some_list[-1]]*(target_len - len(some_list))
+        def _to_list(x):
+            if x is None:
+                return []
+            if isinstance(x, (int, float, str)):
+                return [x]
+            return list(x)
+        xs = _to_list(x)
+        ymins = _pad_or_truncate(_to_list(ymin), len(xs))
+        ymaxs = _pad_or_truncate(_to_list(ymax), len(xs))
+        colorss = _pad_or_truncate(_to_list(colors), len(xs))
+        lss = _pad_or_truncate(_to_list(linestyles), len(xs))
+        for i in range(len(xs)):
+            if i == 0 and "label" in kwargs:
+                self._plot([xs[i]]*2, [ymins[i], ymaxs[i]], None, None, None, c=colorss[i], ls=lss[i], label=kwargs["label"])
+            else:
+                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"}
@@ -221,6 +257,40 @@ class BaseAxes:
         if len(args) == 1:
             kwargs["fmt"] = args[0]
         return self._plot(x,y,settings=settings, **kwargs)
+    
+    def axvline(self, x, ymin=0, ymax=0, **kwargs):
+        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)
+
+    def axhline(self, y, xmin=0, xmax=0, **kwargs):
+        kws = {"fmt", "base", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "label"}
+        kwargs = self._check_kwargs("axhline", kws, **kwargs)
+        if isinstance(self, Secondary):
+            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)
+
+    def axvspan(self, xmin, xmax, ymin=0, ymax=1, **kwargs):
+        kws = {"c", "color", "alpha", "label"}
+        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)
+
+    def axhspan(self, ymin, ymax, xmin=0, xmax=1, **kwargs):
+        kws = {"c", "color", "alpha", "label"}
+        kwargs = self._check_kwargs("axhspan", kws, **kwargs)
+        if isinstance(self, Secondary):
+            self._primary._ext_xmin = self._primary._ext_xmax = True
+        else:
+            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)
 
     def set_ylabel(self, label):
         self._axis_options["ylabel"] = f"{{{tex_text(label)}}}"
@@ -331,6 +401,13 @@ class BaseAxes:
         txt = Text(self, x, y, s, **kwargs)
         self._elements.append(txt)
 
+    def magnify(self, x_p, y_p, x_m, y_m, zoom, size, **kwargs):
+        kws = {"shape", "connect"}
+        kwargs = self._check_kwargs("magnify", kws, **kwargs)
+        n = self._fig._add_spy(zoom, size, **kwargs)
+        self._coordinates.update({f"spypoint{n}": (x_p,y_p)})
+        self._coordinates.update({f"spyviewr{n}": (x_m,y_m)})
+
     def _add_legend_entries(self):
         if self._add_legend == "": return ""
         axs, labs = self._add_legend
@@ -346,6 +423,9 @@ class BaseAxes:
     def _content_tex(self, filename):
         ouptut = "\n".join(e._to_tex(filename) for e in self._elements)
         ouptut += self._add_legend_entries()
+        for coord in self._coordinates:
+            x,y = self._coordinates[coord]
+            ouptut += f"\n\\coordinate ({coord}) at ({x},{y});"
         return ouptut
     
     def _get_hard_range(self,which):
@@ -364,13 +444,20 @@ class BaseAxes:
         mode = "lin"
         if arg in self._axis_options:
             mode = self._axis_options[arg]
+        common = self._elements.copy()
+        if "x" in which and isinstance(self,Axes) and self._secondary_y:
+            common += self._secondary_y._elements
         if which in self._axis_options:
-            for e in self._elements:
+            for e in common:
                 e._filter(which, self._axis_options[which])
             return (self._axis_options[which], True, mode)
+        values = [e._get_erange(which) for e in common]
+        values = [v for v in values if v is not None]
+        if not values:
+            return (None, False, mode)
         if "min" in which:
-            return (min([e._get_erange(which) for e in self._elements]), False, mode)
-        return (max([e._get_erange(which) for e in self._elements]), False, mode)
+            return (min(values), False, mode)
+        return (max(values), False, mode)
     
     def _get_limit(self, which):
         arg = f"{which[0]}mode"
@@ -387,6 +474,15 @@ class BaseAxes:
 
     def _set_range(self, which, value):
         self._axis_options[which] = value
+        if isinstance(self, Axes):
+            if which == "xmin":
+                self._ext_xmin = True
+            if which == "xmax":
+                self._ext_xmax = True
+        if which == "ymin":
+            self._ext_ymin = True
+        if which == "ymax":
+            self._ext_ymax = True
         for e in self._elements:
             e._filter(which, value)
 
@@ -427,6 +523,9 @@ class Axes(BaseAxes):
         self._cbar_h = False
         self._polar = polar
 
+        self._ext_xmin = False
+        self._ext_xmax = False
+
         def _posit_string(): # returns neighbour, neighbour corner, anchor
             i = self._index
             if i == 0:
@@ -481,28 +580,6 @@ class Axes(BaseAxes):
             self._axis_options["log basis x"] = kwargs["base"]
         return self._plot(x, y, **kwargs)
 
-    def vlines(self, x, ymin, ymax, colors="k", linestyles="solid", **kwargs):
-        kws = {"label"}
-        kwargs = self._check_kwargs("vlines", kws, **kwargs)
-        def _pad_or_truncate(some_list, target_len):
-            return some_list[:target_len] + [some_list[-1]]*(target_len - len(some_list))
-        def _to_list(x):
-            if x is None:
-                return []
-            if isinstance(x, (int, float, str)):
-                return [x]
-            return list(x)
-        xs = _to_list(x)
-        ymins = _pad_or_truncate(_to_list(ymin), len(xs))
-        ymaxs = _pad_or_truncate(_to_list(ymax), len(xs))
-        colorss = _pad_or_truncate(_to_list(colors), len(xs))
-        lss = _pad_or_truncate(_to_list(linestyles), len(xs))
-        for i in range(len(xs)):
-            if i == 0 and "label" in kwargs:
-                self._plot([xs[i]]*2, [ymins[i], ymaxs[i]], None, None, None, c=colorss[i], ls=lss[i], label=kwargs["label"])
-            else:
-                self._plot([xs[i]]*2, [ymins[i], ymaxs[i]], None, None, None, c=colorss[i], ls=lss[i])
-
     def imshow(self, *args, **kwargs):
         #kws = {"fmt", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "marker", "markersize", "ms", "label"}
         #kwargs = self._check_kwargs("imshow", kws, **kwargs)
@@ -610,6 +687,7 @@ class Axes(BaseAxes):
         if self._polar:
             raise Exception("Cannot create twinx() on polar plot.")
         self._secondary_y = Secondary(self)
+        self._ext_xmin = self._ext_xmax = True
         return self._secondary_y
     
     def _export_imshow(self, *args, **kwargs):
@@ -653,13 +731,38 @@ class Axes(BaseAxes):
             axis_opt_str += ",\n".join(self._axis_args)
         if TikzConfig.SCHOOL_AXIS:
             axis_opt_str += f",\n axis lines=middle,\n xlabel style={{at={{(ticklabel* cs:{1+TikzConfig.SCHOOL_AXIS_LABEL_MARGIN})}},anchor=north}},\n ylabel style={{at={{(ticklabel* cs:{1+TikzConfig.SCHOOL_AXIS_LABEL_MARGIN})}},anchor=east}}"
+            if ("xmin" in self._axis_options and self._axis_options["xmin"] == 0) or ("xmax" in self._axis_options and self._axis_options["xmax"] == 0):
+                self._axis_options["extra x ticks"] = r"{0}"
+            if ("ymin" in self._axis_options and self._axis_options["ymin"] == 0) or ("ymax" in self._axis_options and self._axis_options["ymax"] == 0):
+                self._axis_options["extra y ticks"] = r"{0}"
         if TikzConfig.USE_GROUPPLOTS:
-            #axis_opt_str += f",\n set layers,\n axis line style={{on layer=axis foreground}}"
-            axis_opt_str += f",\n axis on top"
+            if TikzConfig.SCHOOL_AXIS:
+                axis_opt_str += f",\n set layers,\n axis line style={{on layer=axis foreground}}"
+            else:
+                axis_opt_str += f",\n axis on top"
+        if self._ext_xmin or self._ext_xmax:
+            lower = self._get_range("xmin")
+            upper = self._get_range("xmax")
+            xm, xM = self._fig._range_setting(lower[0], upper[0], lower[2])
+            if self._ext_xmin:
+                self._axis_options["xmin"] = self._fig._next_limname("xmin", self._axis_options.get("xmin", xm))
+            if self._ext_xmax:
+                self._axis_options["xmax"] = self._fig._next_limname("xmax", self._axis_options.get("xmax", xM))
+        if self._ext_ymin or self._ext_ymax:
+            lower = self._get_range("ymin")
+            upper = self._get_range("ymax")
+            ym, yM = self._fig._range_setting(lower[0], upper[0], lower[2])
+            if self._ext_ymin:
+                self._axis_options["ymin"] = self._fig._next_limname("ymin", self._axis_options.get("ymin", ym))
+            if self._ext_ymax:
+                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())
-        axis_opt_str += self._colorbar
+        if self._colorbar:
+            axis_opt_str += self._colorbar
+        elif self._cmap_bar:
+            axis_opt_str += f",\n colormap={self._cmap_bar._generate_tex_colormap(self._cmap_bar._cmap)}"
         return axis_opt_str
 
     
@@ -690,27 +793,27 @@ class Axes(BaseAxes):
     def _get_index(self):
         return self._index
     
-    def _to_tex(self, filename):
+    def _to_tex(self, filename, single):
         lines = []
         lines2 = []
-        if self._polar and TikzConfig.USE_GROUPPLOTS:
+        if self._polar and TikzConfig.USE_GROUPPLOTS and not single:
             lines.append(f"\\nextgroupplot[alias={self._axis_options['alias']}, width={self._width}, height={self._height}, hide axis]")
             lines2.append("\\begin{polaraxis}")
             lines2.append(f"[{self._axis_option_string()}]")
             lines2.append(self._content_tex(filename))
             lines2.append("\\end{polaraxis}")
         else:
-            if TikzConfig.USE_GROUPPLOTS:
+            if TikzConfig.USE_GROUPPLOTS and not single:
                 lines.append("\\nextgroupplot")
             if self._polar:
                 lines.append("\\begin{polaraxis}")
-            elif not TikzConfig.USE_GROUPPLOTS:
+            elif not TikzConfig.USE_GROUPPLOTS or (TikzConfig.USE_GROUPPLOTS and single):
                 lines.append("\\begin{axis}")
             lines.append(f"[{self._axis_option_string()}]")
             lines.append(self._content_tex(filename))
             if self._polar:
                 lines.append("\\end{polaraxis}")
-            elif not TikzConfig.USE_GROUPPLOTS:
+            elif not TikzConfig.USE_GROUPPLOTS or (TikzConfig.USE_GROUPPLOTS and single):
             
                 lines.append("\\end{axis}")
             if self._secondary_y is not None:
@@ -749,6 +852,16 @@ class Secondary(BaseAxes):
         axis_opt_str = ""
         if self._axis_args:
             axis_opt_str += ",\n".join(self._axis_args)
+        if self._ext_ymin or self._ext_ymax:
+            lower = self._get_range("ymin")
+            upper = self._get_range("ymax")
+            ym, yM = self._fig._range_setting(lower[0], upper[0], lower[2])
+            if self._ext_ymin:
+                self._axis_options["ymin"] = self._fig._next_limname("ymin", self._axis_options.get("ymin", ym))
+            if self._ext_ymax:
+                self._axis_options["ymax"] = self._fig._next_limname("ymax", self._axis_options.get("ymax", yM))
+        self._axis_options["xmin"] = self._primary._axis_options["xmin"]
+        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())

{tikzplot42-0.3.4 → tikzplot42-0.3.7}/src/tikzplot/axes.pyi

@@ -258,6 +258,18 @@ class BaseAxes:
         Draw horizontal lines to the selected axis.
         """
         ...
+    def vlines(
+        self,
+        x: Union[float, Sequence[float]],
+        ymin: Union[float, Sequence[float]],
+        ymax: Union[float, Sequence[float]],
+        colors: Union[str, Sequence[str]] = "k",
+        linestyles: Union[str, Sequence[str]] = "solid",
+    ) -> None: 
+        """
+        Draw vertical lines to the selected axis.
+        """
+        ...
     def hist(
         self,
         x: Union[ArrayLike, Sequence[ArrayLike]],
@@ -313,6 +325,132 @@ class BaseAxes:
             Mark size in pt
         """
         ...
+
+    def axvline(self, x:float, ymin:float=0, ymax:float=1, alpha:Optional[float] = ..., color:Optional[ColorLike] = ..., linestyle:Optional[str] = ..., linewidth:Optional[float] = ..., label:Optional[str] = ...) -> None:
+        """
+        Draw a vertical line to the selected axis at given x coordinate.
+        
+        Parameters
+        ----------
+        x: float
+            X coordinate of the line(s)
+        
+        ymin, ymax: float, optional
+            Y relative coordinate of the lower and upper end of the line
+        
+        alpha: float, optional
+            Opacity
+
+        color or c: all matplotlib color formats (without X11/xkcd), optional
+            color of line: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+
+        linestyle or ls: str, optional
+            Line style
+
+        linewidth or lw: float, optional
+            Line width in pt
+
+        label: str, optional
+            Legend entry
+        """
+
+    def axhline(self, y:float, xmin:float=0, xmax:float=1, alpha:Optional[float] = ..., color:Optional[ColorLike] = ..., linestyle:Optional[str] = ..., linewidth:Optional[float] = ..., label:Optional[str] = ...) -> None:
+        """
+        Draw a horizontal line to the selected axis at given y coordinate.
+        
+        Parameters
+        ----------
+        y: float
+            Y coordinate of the line(s)
+        
+        xmin, xmax: float, optional
+            X relative coordinate of the left and right end of the line
+        
+        alpha: float, optional
+            Opacity
+
+        color or c: all matplotlib color formats (without X11/xkcd), optional
+            color of line: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+
+        linestyle or ls: str, optional
+            Line style
+
+        linewidth or lw: float, optional
+            Line width in pt
+
+        label: str, optional
+            Legend entry
+        """
+
+    def axvspan(self, xmin:float, xmax:float, ymin:float=0, ymax:float=1, alpha:Optional[float] = ..., color:Optional[ColorLike] = ..., label:Optional[str] = ...) -> None:
+        """
+        Draw a background vertical span to the selected axis between given x coordinates.
+
+        Parameters
+        ----------
+        xmin, xmax: float
+            X coordinates of the left and right end of the span
+        
+        ymin, ymax: float, optional
+            Y relative coordinate of the lower and upper end of the span
+        
+        alpha: float, optional
+            Opacity
+
+        color or c: all matplotlib color formats (without X11/xkcd), optional
+            color of line: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+
+        label: str, optional
+            Legend entry
+        """
+
+    def axhspan(self, ymin:float, ymax:float, xmin:float=0, xmax:float=1, alpha:Optional[float] = ..., color:Optional[ColorLike] = ..., label:Optional[str] = ...) -> None:
+        """
+        Draw a background horizontal span to the selected axis between given y coordinates.
+
+        Parameters
+        ----------
+        ymin, ymax: float
+            Y coordinates of the lower and upper end of the span
+        
+        xmin, xmax: float, optional
+            X relative coordinate of the left and right end of the span
+        
+        alpha: float, optional
+            Opacity
+
+        color or c: all matplotlib color formats (without X11/xkcd), optional
+            color of line: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+
+        label: str, optional
+            Legend entry
+        """
+
+    def magnify(self, x_p: float, y_p: float, x_m: float, y_m: float, zoom: float, size: float, **kwargs) -> int:
+        """
+        Add a spyviewer to the selected axis.
+
+        Parameters
+        ----------
+        x_p, y_p: float
+            Spy point coordinates in axis units
+
+        x_m, y_m: float
+            Spy view coordinates in cm
+
+        zoom: float
+            Spy zoom
+
+        size: float
+            Spy viewer size in cm
+
+        shape: {"circle"}, optional
+            Spy shape, default square
+
+        connect: bool, optional
+            Connect spy point and view with a line, default False
+        """
+        ...
     
     def set_ylabel(self, label: str) -> None: 
         """
@@ -342,13 +480,14 @@ class BaseAxes:
         ...
     def legend(self, *args: Any, loc: Optional[Union[int,str,Tuple[float,float]]] = ...) -> None:
         """
-        Show legend for the selected axis.
+        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).
 
         Parameters
         ----------
         *args:
             - single arg: list/tuple, optional: list of labels to assign to axis elements (in given order assigned to plotted elements in the order of plotting). If label is used on any of the elements, the original label is overwritten.
             - two args: list/tuple, optional: element, label - assign labels to plots (use references of plots which are returned in plot commands). In case that a plot already has a label, both will be displayed. This is the only option to merge the legend entries for double-axis (twinx) plots.
+            
         loc: int, str or tuple, optional
             Location of legend (as in matplotlib: 1 - upper right, 2 - upper left, ... or with tuple of relative coordinates).
 
@@ -441,18 +580,6 @@ class Axes(BaseAxes):
             Mark size in pt
         """
         ...
-    def vlines(
-        self,
-        x: Union[float, Sequence[float]],
-        ymin: Union[float, Sequence[float]],
-        ymax: Union[float, Sequence[float]],
-        colors: Union[str, Sequence[str]] = "k",
-        linestyles: Union[str, Sequence[str]] = "solid",
-    ) -> None: 
-        """
-        Draw vertical lines to the selected axis.
-        """
-        ...
     def imshow(self, *args: Any, cmap: Optional[str] = ...) -> Tuple[Any, str, float, float]: 
         """
         Draw image to the selected axis from array. Uses matplotlib imshow() to export to PDF, then inputs the image to the axis. Return may be used to initialize Colorbar().

{tikzplot42-0.3.4 → tikzplot42-0.3.7}/src/tikzplot/axes3d.py

@@ -553,9 +553,9 @@ class Axes3:
     def _get_index(self):
         return self._index
     
-    def _to_tex(self, filename):
+    def _to_tex(self, filename, single):
         lines = []
-        if TikzConfig.USE_GROUPPLOTS:
+        if TikzConfig.USE_GROUPPLOTS and not single:
             lines.append("\\nextgroupplot")
             lines.append(f"[{self._axis_option_string()}]")
             lines.append(self._content_tex(filename))

{tikzplot42-0.3.4 → tikzplot42-0.3.7}/src/tikzplot/config.py

@@ -6,6 +6,7 @@ class _TikzConfig:
     def __init__(self):
 
         self.USE_DECIMAL_COMMA: bool = False
+        self.THOUSANDS_SEP: str = ""
 
         self.LEGEND_REL_X: float = 0.03
         self.LEGEND_REL_Y: float = 0.03

{tikzplot42-0.3.4 → tikzplot42-0.3.7}/src/tikzplot/config.pyi

@@ -7,6 +7,7 @@ from typing import TypedDict, Unpack, Any, ClassVar, Protocol
 
 class _ConfigParams(TypedDict, total=False):
     USE_DECIMAL_COMMA: bool
+    THOUSANDS_SEP: str
 
     LEGEND_REL_X: float
     LEGEND_REL_Y: float