tikzplot42 0.3.6__tar.gz → 0.3.8__tar.gz

{tikzplot42-0.3.6 → tikzplot42-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplot42
-Version: 0.3.6
+Version: 0.3.8
 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
@@ -739,11 +739,13 @@ Some basic plot commands are already implemented with commonly used arguments:
 - `stem()`,
 - `fill_between()`,
 - `hlines()/vlines()`,
-- `historgam()`,
+- `histogram()`,
 - `step()`,
 - `imshow()`,
 - `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). 
+- `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`),

{tikzplot42-0.3.6 → tikzplot42-0.3.8}/README.md

@@ -37,11 +37,13 @@ Some basic plot commands are already implemented with commonly used arguments:
 - `stem()`,
 - `fill_between()`,
 - `hlines()/vlines()`,
-- `historgam()`,
+- `histogram()`,
 - `step()`,
 - `imshow()`,
 - `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). 
+- `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`),

{tikzplot42-0.3.6 → tikzplot42-0.3.8}/pyproject.toml

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

{tikzplot42-0.3.6 → tikzplot42-0.3.8}/src/tikzplot/axes.py

@@ -17,17 +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):
@@ -182,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"}
@@ -227,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=1, **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=1, **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,10 +395,15 @@ class BaseAxes:
                 for i in range(len(labs)):
                     self._elements[i]._set_label(tex_text(labs[i]))
 
-    def text(self, x, y, s, **kwargs):
+    def text(self, x, y, s, on_top=True, **kwargs):
         kws = {"alpha", "color", "c", "fontsize", "size", "backgroundcolor", "horizontalalignment", "ha", "verticalalignment", "va", "rotation", "label"}
         kwargs = self._check_kwargs("text", kws, **kwargs)
-        txt = Text(self, x, y, s, **kwargs)
+        if on_top:
+            coord = self._fig._next_coordinate_name()
+            txt = Text(self, x, y, coord, s, **kwargs)
+            self._fig._add_text(txt)
+        else:
+            txt = Text(self, x, y, None, s, **kwargs)
         self._elements.append(txt)
 
     def magnify(self, x_p, y_p, x_m, y_m, zoom, size, **kwargs):
@@ -380,13 +449,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"
@@ -403,6 +479,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)
 
@@ -443,6 +528,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:
@@ -497,28 +585,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)
@@ -626,6 +692,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):
@@ -669,9 +736,31 @@ 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())
@@ -709,27 +798,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:
@@ -768,6 +857,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.6 → tikzplot42-0.3.8}/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]],
@@ -314,9 +326,109 @@ class BaseAxes:
         """
         ...
 
-    def spy(self, x_p: float, y_p: float, x_m: float, y_m: float, zoom: float, size: float, **kwargs) -> int:
+    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 spy to the selected axis.
+        Add a spyviewer to the selected axis.
 
         Parameters
         ----------
@@ -368,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).
 
@@ -467,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.6 → tikzplot42-0.3.8}/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.6 → tikzplot42-0.3.8}/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
@@ -28,7 +29,7 @@ class _TikzConfig:
 
         self.SHARED_AXIS_REL_MARGIN: float = 0.08
 
-        self.SAVE_DATAPOINTS: bool = True
+        self.SAVE_DATAPOINTS: bool = False
         self.DATAPOINTS_DIR: str = "datapoints"  # ignored if SAVE_DATAPOINTS == False
         self.UPDATE_DATA_ONLY: bool = False       # ignored if SAVE_DATAPOINTS == False
         self.UPDATE_STYLE_ONLY: bool = False      # ignored if SAVE_DATAPOINTS == False

{tikzplot42-0.3.6 → tikzplot42-0.3.8}/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