tikzplot42 0.3.0__tar.gz → 0.3.3__tar.gz

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplot42
-Version: 0.3.0
+Version: 0.3.3
 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
@@ -705,6 +705,10 @@ A clean version of PltToTikz, this time as Python package. Easy to use: only rep
 
 Please let me know if you find any bugs or unexpected behaviour. Examples may be found in repository under `tests/` directory.
 
+<p align="center">
+  <img src="https://github.com/ZanAmb/TikzPlot/blob/main/tests/demo.png" width="60%">
+</p>
+
 # Installation
 NEW: PyPI: `pip install tikzplot42`.
 Alternativley, download this package and install using: `pip install [path]`, where [path] is the path to the directory, containing `pyproject.toml`.
@@ -718,7 +722,8 @@ Instead of using `import matplotlib.pyplot (as plt)`, use `import tikzplot.plots
 - `\pgfplotsset{compat=1.18}` (may be lower, but compilation is not guaranteed),
 - `\usepgfplotslibrary{fillbetween}` (if you use fill-between plots),
 - `\usepgfplotslibrary{groupplots}` (recommended for best results, enabled by default, may be avoided by setting TikzConfig USE_GROUPPLOTS=False),
-- `\usepackage{xcolor}` (recommended for best colors, works without but needs change of TikzConfig USE_XCOLOR=False).
+- `\usepackage{xcolor}` (recommended for best colors, works without but needs change of TikzConfig USE_XCOLOR=False),
+- `\usepgfplotslibrary{polar}` required for polar axis.
 
 Export using `plt.savefig("example_graph.tex")` (recommended) or `plt.show()`.
 Then use the generated file as `\input{example_graph.tex}`.
@@ -735,7 +740,9 @@ Some basic plot commands are already implemented with commonly used arguments:
 - `fill-between()`,
 - `hlines()/vlines()`,
 - `historgam()`,
-- `imshow()`.
+- `step()`,
+- `imshow()`,
+- `text()`.
 
 #### Figures
 - `plt.figure()` (currently only to give you figure object or to set `figsize`),

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/README.md

@@ -3,6 +3,10 @@ A clean version of PltToTikz, this time as Python package. Easy to use: only rep
 
 Please let me know if you find any bugs or unexpected behaviour. Examples may be found in repository under `tests/` directory.
 
+<p align="center">
+  <img src="https://github.com/ZanAmb/TikzPlot/blob/main/tests/demo.png" width="60%">
+</p>
+
 # Installation
 NEW: PyPI: `pip install tikzplot42`.
 Alternativley, download this package and install using: `pip install [path]`, where [path] is the path to the directory, containing `pyproject.toml`.
@@ -16,7 +20,8 @@ Instead of using `import matplotlib.pyplot (as plt)`, use `import tikzplot.plots
 - `\pgfplotsset{compat=1.18}` (may be lower, but compilation is not guaranteed),
 - `\usepgfplotslibrary{fillbetween}` (if you use fill-between plots),
 - `\usepgfplotslibrary{groupplots}` (recommended for best results, enabled by default, may be avoided by setting TikzConfig USE_GROUPPLOTS=False),
-- `\usepackage{xcolor}` (recommended for best colors, works without but needs change of TikzConfig USE_XCOLOR=False).
+- `\usepackage{xcolor}` (recommended for best colors, works without but needs change of TikzConfig USE_XCOLOR=False),
+- `\usepgfplotslibrary{polar}` required for polar axis.
 
 Export using `plt.savefig("example_graph.tex")` (recommended) or `plt.show()`.
 Then use the generated file as `\input{example_graph.tex}`.
@@ -33,7 +38,9 @@ Some basic plot commands are already implemented with commonly used arguments:
 - `fill-between()`,
 - `hlines()/vlines()`,
 - `historgam()`,
-- `imshow()`.
+- `step()`,
+- `imshow()`,
+- `text()`.
 
 #### Figures
 - `plt.figure()` (currently only to give you figure object or to set `figsize`),

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/pyproject.toml

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

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/src/tikzplot/axes.py

@@ -2,7 +2,9 @@ import numpy as _np
 import matplotlib.pyplot as _plt
 
 from .elements import Graph
+from .texts import Text
 from .config import TikzConfig
+from .colorbar import Colorbar
 from .state import _next_imshow_num, main_name
 from .latex_special import tex_text
 
@@ -20,6 +22,8 @@ class BaseAxes:
         self._add_legend = ""
 
     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)
         return e
@@ -44,14 +48,33 @@ class BaseAxes:
             return self._plot(x,y,fmt=fmt, **kwargs)
 
     def scatter(self, x, y, *args, **kwargs):
-        kws = {"fmt", "alpha", "color", "c", "marker", "markersize", "s", "label"}
+        kws = {"fmt", "alpha", "color", "c", "marker", "markersize", "s", "label", "cmap", "vmin", "vmax"}
         kwargs = self._check_kwargs("scatter", kws, **kwargs)
 
         if "s" in kwargs:
-            kwargs["ms"] = kwargs.pop("s")
-
-        return self._plot(x, y, **kwargs, ls="")
+            s = kwargs.pop("s")
+            if not isinstance(s, (int, float)):
+                s = [i/50 for i in s]
+            else:
+                s /= 50
+            kwargs["ms"] = s
 
+        try:
+            c = kwargs.get("c", kwargs.get("color", None))
+            if len(c) == len(x):
+                if isinstance(c[0], (int, float)):
+                    if "cmap" not in kwargs:
+                        kwargs["cmap"] = Colorbar(cmap="viridis", lower=min(c), upper=max(c))
+                    else:
+                        cmap = kwargs["cmap"]
+                        if isinstance(cmap, str):
+                            vmin = kwargs.pop("vmin", min(c))
+                            vmax = kwargs.pop("vmax", max(c))
+                            kwargs["cmap"] = Colorbar(cmap=cmap, lower=vmin, upper=vmax)
+        except: pass
+        
+        return self._plot(x, y, **kwargs, ls="", settings=["scatter"])
+                        
     def semilogy(self, x, y, *args, **kwargs):
         kws = {"fmt", "base", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "marker", "markersize", "ms", "label"}
         kwargs = self._check_kwargs("semilogy", kws, **kwargs)
@@ -188,6 +211,16 @@ class BaseAxes:
             counts = _np.cumsum(counts)
 
         return self._plot(centers, counts, settings=settings, **kwargs)
+    
+    def step(self, x, y, *args, **kwargs):
+        kws = {"fmt", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "marker", "markersize", "ms", "label", "where"}
+        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}"]
+        if len(args) == 1:
+            kwargs["fmt"] = args[0]
+        return self._plot(x,y,settings=settings, **kwargs)
 
     def set_ylabel(self, label):
         self._axis_options["ylabel"] = f"{{{tex_text(label)}}}"
@@ -292,6 +325,12 @@ class BaseAxes:
                 for i in range(len(labs)):
                     self._elements[i]._set_label(tex_text(labs[i]))
 
+    def text(self, x, y, s, **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)
+        self._elements.append(txt)
+
     def _add_legend_entries(self):
         if self._add_legend == "": return ""
         axs, labs = self._add_legend
@@ -468,7 +507,7 @@ class Axes(BaseAxes):
         #kws = {"fmt", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "marker", "markersize", "ms", "label"}
         #kwargs = self._check_kwargs("imshow", kws, **kwargs)
         self._imshow = (args, kwargs)
-        self._axis_args.add("axis on top")
+        #self._axis_args.add("axis on top")
         self._axis_options["enlargelimits"] = "false"
         #self._fig._add_global("\\pgfplotsset{set layers}")
         data = args[0]
@@ -486,7 +525,6 @@ class Axes(BaseAxes):
         self._axis_options["title"] = f"{{{tex_text(title)}}}"
 
     def grid(self, visible=True, which="major", **kwargs):
-
         if not visible:
             self._axis_options["grid"] = "none"
             return
@@ -512,7 +550,7 @@ class Axes(BaseAxes):
             kwargs = self._check_kwargs("grid", accepted_kwargs, **kwargs)
             g = Graph(self, None, None, None, None, **kwargs)._style_string()
             self._axis_options[f"{selector}grid style"] = f"{{{g}}}"
-    
+            
     def set_minorticks_num(self, num):
         self._axis_options["minor tick num"] = num
 
@@ -616,7 +654,8 @@ class Axes(BaseAxes):
         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 TikzConfig.USE_GROUPPLOTS:
-            axis_opt_str += f",\n set layers,\n axis line style={{on layer=axis foreground}}"
+            #axis_opt_str += f",\n set layers,\n axis line style={{on layer=axis foreground}}"
+            axis_opt_str += f",\n axis on top"
         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())
@@ -654,23 +693,31 @@ class Axes(BaseAxes):
     def _to_tex(self, filename):
         lines = []
         lines2 = []
-        if TikzConfig.USE_GROUPPLOTS:
-            lines.append("\\nextgroupplot")
-        if self._polar:
-            lines.append("\\begin{polaraxis}")
-        elif not TikzConfig.USE_GROUPPLOTS:
-            lines.append("\\begin{axis}")
-        lines.append(f"[{self._axis_option_string()}]")
-        lines.append(self._content_tex(filename))
-        if self._polar:
-            lines.append("\\begin{polaraxis}")
-        elif not TikzConfig.USE_GROUPPLOTS:
-            lines.append("\\end{axis}")
-        if self._secondary_y is not None:
-            lines2.append("\\begin{axis}")
-            lines2.append(f"[{self._secondary_y._axis_option_string()}]")
-            lines2.append(self._secondary_y._content_tex(filename))
-            lines2.append("\\end{axis}")
+        if self._polar and TikzConfig.USE_GROUPPLOTS:
+            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:
+                lines.append("\\nextgroupplot")
+            if self._polar:
+                lines.append("\\begin{polaraxis}")
+            elif not TikzConfig.USE_GROUPPLOTS:
+                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:
+            
+                lines.append("\\end{axis}")
+            if self._secondary_y is not None:
+                lines2.append("\\begin{axis}")
+                lines2.append(f"[{self._secondary_y._axis_option_string()}]")
+                lines2.append(self._secondary_y._content_tex(filename))
+                lines2.append("\\end{axis}")
         return lines, lines2
 
     def set(self, **kwargs):
@@ -690,7 +737,7 @@ class Secondary(BaseAxes):
         self._axis_options["axis x line"] = "none"
         self._axis_options["at"] = f"{{({primary._axis_options['alias' if 'alias' in primary._axis_options else 'name']}.south west)}}"
         self._axis_options["anchor"] = "south west"
-        self._axis_options["y label style"] = r"{at={(1.1,0.5)}, rotate=180}"
+        self._axis_options["y label style"] = r"{at={(" + str(TikzConfig.SEC_YLABEL_LOC[0]) + "," + str(TikzConfig.SEC_YLABEL_LOC[1]) + ")}, rotate=180}"
 
         self._fig = primary._fig
 

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/src/tikzplot/axes.pyi

@@ -1,10 +1,12 @@
 from typing import Any, Optional, Sequence, Tuple, Union, Literal
 import numpy as np
+from .colorbar import Colorbar
 
 ArrayLike = Union[Sequence[float], np.ndarray]
 ColorLike = Union[str, Sequence[float]]
 LineStyle = Literal["-", "--", "-.", ":", "solid", "dashed", "dashdot", "none", ""]
 MarkerStyle = Literal["o", "s", "^", "v", "x", "+", ".", "*", "None", ""]
+FontSize = Literal["xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large"]
 
 
 class BaseAxes:   
@@ -45,8 +47,8 @@ class BaseAxes:
         """
         ...
 
-    def scatter(self, x: ArrayLike = ..., y: ArrayLike = ..., fmt: Optional[str] = ..., *,alpha: Optional[float] = ..., color: Optional[ColorLike] = ..., c: Optional[ColorLike] = ...,
-             marker: Optional[MarkerStyle] = ..., markersize: Optional[float] = ..., s: Optional[float] = ...,  label:Optional[str]=...) -> None:
+    def scatter(self, x: ArrayLike = ..., y: ArrayLike = ..., fmt: Optional[str] = ..., *,alpha: Optional[float] = ..., color: Optional[Union[Sequence[ColorLike], ColorLike]] = ..., c: Optional[ColorLike] = ...,
+             marker: Optional[MarkerStyle] = ..., markersize: Optional[Union[Sequence[float], float]] = ..., s: Optional[Union[Sequence[float], float]] = ...,  label:Optional[str]=..., cmap: Optional[Union[str, Colorbar]], vmin: Optional[float] = ..., vmax: Optional[float] = ...) -> None:
         """
         Draw a scatter plot to the selected axis.
         
@@ -61,8 +63,9 @@ class BaseAxes:
         alpha: float, optional
             Opacity
 
-        color or c: all matplotlib color formats (without X11/xkcd), optional
-            color of line and markers: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+        color or c: array like or single: all matplotlib color formats (without X11/xkcd) or float for colormap, optional
+            color of line and markers: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible. Note that if the sequence if of the same length as x, it will be interpreted as color sequence for each point, otherwise it will be interpreted as a single color for all points.
+
 
         label: str, optional
             Legned entry
@@ -70,8 +73,14 @@ class BaseAxes:
         marker: str, optional
             Marker type
 
-        markersize or s: float, optional
-            Mark size in pt
+        markersize or s: ArrayLike or float, optional
+            Mark size in pt (or in 1/50 pt for s), if a sequence of same length as x, it will be interpreted as size for each point, otherwise it will be interpreted as a single size for all points.
+
+        cmap: str or Colorbar, optional
+            Colormap for scatter points, if color is given as float or sequence of floats. Can be a colormap name or a Colorbar object.
+
+        vmin, vmax: float, optional
+            Colorbar limits for scatter points, if color is given sequence of floats and cmap is given as string, otherwise ignored. If cmap is given as str and no vmin or vmax is provided, they will be set to the min and max of color sequence.
         """
         ...
     def semilogy(self, x: ArrayLike = ..., y: ArrayLike = ..., base: Optional[float] = 10,  fmt: Optional[str] = ...,*, alpha: Optional[float] = ..., color: Optional[ColorLike] = ..., c: Optional[ColorLike] = ...,
@@ -202,6 +211,41 @@ class BaseAxes:
 
         """
         ...
+
+    def text(self, x: float, y: float, s: str, color: Optional[ColorLike] = ..., c: Optional[ColorLike] = ..., fontsize: Optional[FontSize] = ..., size: Optional[FontSize] = ..., backgroundcolor: Optional[ColorLike] = ..., horizontalalignment: Optional[str] = ..., ha: Optional[str] = ..., verticalalignment: Optional[str] = ..., va: Optional[str] = ..., rotation: Optional[Union[float, str]] = ..., label: Optional[str] = ...) -> None:
+        """
+        Add text to the selected axis.
+
+        Parameters
+        ----------
+        x,y: float
+            Text position in axis coordinates
+
+        s: str
+            Text content (LaTeX format)
+
+        color or c: all matplotlib color formats (without X11/xkcd), optional
+            Text color: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+
+        fontsize or size: FontSize, optional
+            Font size
+
+        backgroundcolor: all matplotlib color formats (without X11/xkcd), optional
+            Background color of text box: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+
+        horizontalalignment or ha: {"center", "left", "right"}, optional
+            Horizontal alignment of text
+
+        verticalalignment or va: {"center", "top", "bottom"}, optional
+            Vertical alignment of text
+
+        rotation: float or {"vertical", "horizontal"}, optional
+            Rotation angle in degrees or preset rotation
+
+        label: str, optional
+            Legend entry
+        """
+        ...
     def hlines(
         self,
         y: Union[float, Sequence[float]],
@@ -231,6 +275,44 @@ class BaseAxes:
         Draw histogram to the selected axis.
         """
         ...
+
+    def step(self, x: ArrayLike, y: ArrayLike, *args: Any, where: Literal["pre","post","mid"] = "pre", **kwargs: Any) -> None:
+        """
+        Draw a step plot to the selected axis.
+
+        Parameters
+        ----------
+        x,y : ArrayLike or float
+            Datapoints
+
+        where: {"pre", "post", "mid"}, default "pre"
+            Define where the steps should be placed: before the value (pre), after the value (post), or centered on the value (mid).
+
+        fmt: str, optional
+            Style
+
+        alpha: float, optional
+            Opacity
+
+        color or c: all matplotlib color formats (without X11/xkcd), optional
+            color of line and markers: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+
+        label: str, optional
+            Legned entry
+
+        linestyle or ls: str, optional
+            Line style
+
+        linewidth or lw: float, optional
+            Line width in pt
+        
+        marker: str, optional
+            Marker type
+
+        markersize or ms: float, optional
+            Mark size in pt
+        """
+        ...
     
     def set_ylabel(self, label: str) -> None: 
         """

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/src/tikzplot/axes3d.py

@@ -2,6 +2,7 @@ import numpy as _np
 import matplotlib.pyplot as _plt
 
 from .elements import Graph3
+from .texts import Text3
 from .config import TikzConfig
 #from .state import _next_imshow_num, main_name
 from .latex_special import tex_text
@@ -193,6 +194,12 @@ class Axes3:
             counts = _np.cumsum(counts)
 
         return self._plot(centers, counts, settings=settings, **kwargs)"""
+    
+    def text(self, x, y, z, s, **kwargs):
+        kws = {"alpha", "color", "c", "fontsize", "size", "backgroundcolor", "horizontalalignment", "ha", "verticalalignment", "va", "rotation", "label"}
+        kwargs = self._check_kwargs("text", kws, **kwargs)
+        txt = Text3(self, x, y, z, s, **kwargs)
+        self._elements.append(txt)
 
     def set_title(self, title):
         self._axis_options["title"] = f"{{{tex_text(title)}}}"

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/src/tikzplot/colorbar.py

@@ -100,7 +100,7 @@ class _Colorbar:
         'Spectral':      [(0.6196, 0.0039, 0.2588), (0.9981, 0.9992, 0.746), (0.3686, 0.3098, 0.6353)],
         'coolwarm':      [(0.2298, 0.2987, 0.7537), (0.8674, 0.8644, 0.8626), (0.7057, 0.0156, 0.1502)],
         'bwr':   [(0.0, 0.0, 1.0), (1.0, 0.9961, 0.9961), (1.0, 0.0, 0.0)],
-        'seismic':       [(0.0, 0.0, 0.3), (1.0, 0.9922, 0.9922), (0.5, 0.0, 0.0)],
+         'seismic':       [(0.0, 0.0, 0.3), (0.0, 0.0, 0.6953), (0.1451, 0.1451, 1.0), (0.7098, 0.7098, 1.0), (1.0, 0.7098, 0.7098), (1.0, 0.1451, 0.1451), (0.7824, 0.0, 0.0), (0.5, 0.0, 0.0)],
 
         'twilight':      [(0.8858, 0.85, 0.888), (0.5383, 0.678, 0.7711), (0.3732, 0.3814, 0.706), (0.2867, 0.0824, 0.3933), (0.3154, 0.0794, 0.2681), (0.6457, 0.2616, 0.3125), (0.7905, 0.5983, 0.4862), (0.8857, 0.85, 0.8857)],
         'twilight_shifted':      [(0.1874, 0.0771, 0.2162), (0.36, 0.2069, 0.6029), (0.4114, 0.5368, 0.7467), (0.7387, 0.796, 0.8214), (0.8399, 0.7604, 0.7137), (0.7388, 0.4205, 0.3491), (0.4981, 0.1357, 0.3141), (0.1849, 0.0794, 0.2131)],

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/src/tikzplot/config.py

@@ -21,11 +21,12 @@ class _TikzConfig:
         self.X_LABEL_PADDING: float = 0.6
         self.XTICK_PADDING: float = 0.7
         self.YTICK_PADDING: float = 0.7
+        self.SEC_YLABEL_LOC: tuple[float, float] = (1.2, 0.5)
 
         self.DEFAULT_WIDTH: float = 12
         self.DEFAULT_HEIGHT: float = 10
 
-        self.SHARED_AXIS_REL_MARGIN: float = 0.03
+        self.SHARED_AXIS_REL_MARGIN: float = 0.08
 
         self.SAVE_DATAPOINTS: bool = True
         self.DATAPOINTS_DIR: str = "datapoints"  # ignored if SAVE_DATAPOINTS == False

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/src/tikzplot/config.pyi

@@ -22,6 +22,7 @@ class _ConfigParams(TypedDict, total=False):
     X_LABEL_PADDING: float
     XTICK_PADDING: float
     YTICK_PADDING: float
+    SEC_YLABEL_LOC: tuple[float, float]
 
     DEFAULT_WIDTH: float
     DEFAULT_HEIGHT: float

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/src/tikzplot/elements.py

@@ -38,7 +38,7 @@ class BaseGraph:
         if self._style_str != None:
             return self._style_str
         opts = []
-
+        cmap = None
         def match_ls(input):
             if input in self._LINE_MAP.keys():
                 return self._LINE_MAP[input]
@@ -65,6 +65,10 @@ class BaseGraph:
             r,g,b=ccode
             self._axes._add_col(r,g,b)
             return f"c{r:.3f}{g:.3f}{b:.3f}".replace(".", "")
+        
+        if "scatter" in self._settings:
+            if "cmap" in self._style:
+                cmap = self._style["cmap"]
 
         if "fmt" in self._style:
             fmt = self._style["fmt"]
@@ -83,42 +87,38 @@ class BaseGraph:
             if ls:
                 opts.append(ls)
 
-        if "c" in self._style:
-            sel_col = match_color(self._style['c'])
-            if sel_col:
-                opts.append(f"color={{{sel_col}}}")
-        if "color" in self._style:
-            sel_col = match_color(self._style['color'])
-            if sel_col:
-                opts.append(f"color={{{sel_col}}}")
-        if "ls" in self._style:
-            ls = self._style["ls"]
-            if ls == "":
-                opts.append("only marks")
+        if "c" in self._style or "color" in self._style:
+            if "scatter" in self._settings and self._colors is not None:
+                if isinstance(self._colors[0], (int, float)):
+                    self._colors = [match_color(cmap.color(p)) for p in self._colors]
+                else:
+                    self._colors = [match_color(p) for p in self._colors]
             else:
-                sel_ls = match_ls(ls)
-                if sel_ls:
-                    opts.append(sel_ls)
-        if "linestyle" in self._style:
-            ls = self._style["linestyle"]
+                c = self._style.get("c", self._style.get("color"))
+                sel_col = match_color(c)
+                if sel_col:
+                    opts.append(f"color={{{sel_col}}}")
+
+        if "ls" in self._style or "linestyle" in self._style:
+            ls = self._style.get("ls", self._style.get("linestyle"))
             if ls == "":
                 opts.append("only marks")
             else:
                 sel_ls = match_ls(ls)
                 if sel_ls:
                     opts.append(sel_ls)
-        if "lw" in self._style:
-            opts.append(f"line width={self._style['lw']}pt")
-        if "linewidth" in self._style:
-            opts.append(f"line width={self._style['linewidth']}pt")
+        if "lw" in self._style or "linewidth" in self._style:
+            if "scatter" in self._settings:
+                lw = self._style.get("lw", self._style.get("linewidth"))
+                opts.append(f"line width={lw}pt")
         if "marker" in self._style:
             sel_mark = match_mark(self._style['marker'])
             if sel_mark:
                 opts.append(f"mark={sel_mark}")
-        if "ms" in self._style:
-            opts.append(f"mark size={self._style['ms']}pt")
-        if "marksize" in self._style:
-            opts.append(f"mark size={self._style['marksize']}pt")
+        if "ms" in self._style or "markersize" in self._style:
+            ms = self._style.get("ms", self._style.get("markersize"))
+            if not ("scatter" in self._settings and self._sizes is not None):
+                opts.append(f"mark size={ms}pt")
         if "markerfmt" in self._style:
             col = list(set(self._COLOR_MAP.keys()) & set(fmt))
             if col:
@@ -162,6 +162,20 @@ class BaseGraph:
         if self._path_name: self._settings.append(f"name path={self._path_name}")
         if self._settings:
             opts = self._settings + opts
+        if "scatter" in self._settings and (self._colors is not None or self._sizes is not None):
+            last = 0
+            for i in range(len(self._x)):
+                st = ""
+                if self._colors is not None:
+                    st = f"color={{{self._colors[i]}}},"
+                if self._sizes is not None:
+                    st += f"mark size={self._sizes[i]:.9f}pt"
+                if st not in self._st_dict:
+                    self._st_dict[st] = "s" + str(last+1)
+                    last += 1
+                self._p_dict[i] = self._st_dict[st]
+            opts.append("point meta=explicit symbolic")
+            opts.append(f"scatter/classes={{\n" + ',\n'.join(f"{v}={{{k}}}" for k,v in self._st_dict.items()) + "\n}")
         self._style_str = ",\n".join(str(o) for o in opts)
         return self._style_str
     
@@ -196,12 +210,21 @@ class Graph(BaseGraph):
         super().__init__()
         self._axes = axes
         self._classic = False
+        self._style = style
+        if settings is not None:
+            self._settings = settings
+        if "scatter" in self._settings:
+            self._st_dict = {}
+            self._p_dict = {}
+            self._colors = None
+            self._sizes = None
         if isinstance(coordinates, tuple):
             self._classic = True
             x,y=coordinates
             self._x = np.asarray(x)
             self._y = np.asarray(y)
             mask = np.isfinite(self._x) & np.isfinite(self._y)
+            n0 = len(self._x)
             self._x = self._x[mask]
             self._y = self._y[mask]
             n = len(self._x)
@@ -212,11 +235,28 @@ class Graph(BaseGraph):
 
             if self._yerr is not None:
                 self._yerr = np.asarray(self._yerr)[mask]
+
+            if "scatter" in self._settings:
+                c = self._style.get("c", self._style.get("color", None))
+                if c is not None:
+                    try:
+                        if len(c) == n0:
+                            self._colors = np.asarray(c)[mask]
+                    except: pass
+                s = self._style.get("ms", self._style.get("markersize", None))
+                if s is not None:
+                    try:
+                        if len(s) == n0:
+                            self._sizes = np.asarray(s)[mask]
+                    except: pass
+                if self._colors is None and self._sizes is None:
+                    self._settings.remove("scatter")
+                else:
+                    if self._colors is None:
+                        self._colors = style.get("c", style.get("color", self._axes._get_defcol())) * np.ones(len(self._x))
         else:
             self._special = coordinates
-        self._style = style
         self._label = None
-        self._settings = settings
         if self._settings == None: self._settings = []
 
         self._opacity = 1
@@ -236,6 +276,9 @@ class Graph(BaseGraph):
                 cols += ["yerrminus", "yerrplus"]
             else:
                 cols.append("yerror")
+        if "scatter" in self._settings:
+            if self._p_dict:
+                cols.append("label")                
         return " ".join(cols)
 
     def _rows(self):    
@@ -252,6 +295,9 @@ class Graph(BaseGraph):
                     line += list(self._yerr[i])
                 else:
                     line.append(self._yerr[i])
+            if "scatter" in self._settings:
+                if self._p_dict:
+                    line.append(self._p_dict[i])
             rows.append(" ".join(str(v) for v in line))
         return "\n".join(rows)
     
@@ -266,6 +312,8 @@ class Graph(BaseGraph):
                 table_opts += ",x error=xerror"
             if self._yerr is not None:
                 table_opts += ",y error=yerror"
+            if "scatter" in self._settings and self._p_dict:
+                table_opts += ",meta=label"
             datapoints = f"{header}\n{rows}\n"
             if TikzConfig.SAVE_DATAPOINTS:
                 datapoints = self._save_data(datapoints, filename)
@@ -275,6 +323,8 @@ class Graph(BaseGraph):
                 return f"\\addplot [forget plot,\n{style}] table [{table_opts}] {{{datapoints}}};"
             return ""
         elif TikzConfig.SAVE_DATAPOINTS or not (TikzConfig.SAVE_DATAPOINTS and not TikzConfig.UPDATE_STYLE_ONLY):
+            if self._label and self._axes._legend_on:
+                return f"\\addplot [{style}] {self._special};\\addlegendentry{{{self._label}}}"
             return f"\\addplot [forget plot,\n{style}] {self._special};"
         else:
             return ""
@@ -330,6 +380,12 @@ class Graph(BaseGraph):
         if self._yerr is not None:
             self._yerr = self._yerr[mask]
 
+        if "scatter" in self._settings:
+            if self._colors is not None:
+                self._colors = self._colors[mask]
+            if self._sizes is not None:
+                self._sizes = self._sizes[mask]
+
     def _check_equal(self, x,y):
         if self._classic:
             return np.array_equal(np.asarray(x),self._x) and np.array_equal(np.asarray(y),self._y)
@@ -397,6 +453,11 @@ class Graph(BaseGraph):
                             self._xerr = self._xerr[mask]
                         if self._yerr is not None:
                             self._yerr = self._yerr[mask]
+                        if "scatter" in self._settings:
+                            if self._colors is not None:
+                                self._colors = self._colors[mask]
+                            if self._sizes is not None:
+                                self._sizes = self._sizes[mask]
 
 class Graph3(BaseGraph):
     def __init__(self, axes, coordinates, settings=None, xerr=None, yerr=None, zerr=None, path_name=None, **style):

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/src/tikzplot/plots.py

@@ -101,26 +101,26 @@ def plot(*args, **kwargs):
     _ensure_axes()
     _current_axes.plot(*args, **kwargs)
 
-def scatter(x, y, *args, **kwargs):
+def scatter(*args, **kwargs):
     _ensure_axes()
-    _current_axes.scatter(x, y, *args, **kwargs)
+    _current_axes.scatter(*args, **kwargs)
 
 
-def loglog(x, y, *args, **kwargs):
+def loglog(*args, **kwargs):
     _ensure_axes()
-    _current_axes.loglog(x, y, *args, **kwargs)
+    _current_axes.loglog(*args, **kwargs)
 
-def semilogx(x, y, *args, **kwargs):
+def semilogx(*args, **kwargs):
     _ensure_axes()
-    _current_axes.semilogx(x, y, *args, **kwargs)
+    _current_axes.semilogx(*args, **kwargs)
 
-def semilogy(x, y, *args, **kwargs):
+def semilogy(*args, **kwargs):
     _ensure_axes()
-    _current_axes.semilogy(x, y, *args, **kwargs)
+    _current_axes.semilogy(*args, **kwargs)
 
-def errorbar(x, y, *args, **kwargs):
+def errorbar(*args, **kwargs):
     _ensure_axes()
-    _current_axes.errorbar(x, y, *args, **kwargs)
+    _current_axes.errorbar(*args, **kwargs)
 
 def stem(*args, **kwargs):
     _ensure_axes()
@@ -130,6 +130,10 @@ def fill_between(*args, **kwargs):
     _ensure_axes()
     _current_axes.fill_between(*args, **kwargs)
 
+def text(*args, **kwargs):
+    _ensure_axes()
+    _current_axes.text(*args, **kwargs)
+
 def hlines(*args, **kwargs):
     _ensure_axes()
     _current_axes.hlines(*args, **kwargs)
@@ -142,6 +146,14 @@ def imshow(*args, **kwargs):
     _ensure_axes()
     return _current_axes.imshow(*args, **kwargs)
 
+def hist(*args, **kwargs):
+    _ensure_axes()
+    return _current_axes.hist(*args, **kwargs)
+
+def step(*args, **kwargs):
+    _ensure_axes()
+    return _current_axes.step(*args, **kwargs)
+
 def xticks(*args, **kwargs):
     _ensure_axes()
     _current_axes.set_xticks(*args, **kwargs)
@@ -173,3 +185,6 @@ def clf():
 def gca():
     _ensure_axes()
     return _current_axes
+
+def tight_layout():
+    pass

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/src/tikzplot/plots.pyi

@@ -3,7 +3,8 @@
 from typing import Any, Optional, Tuple, Union, Sequence, Literal
 import numpy as np
 
-from .config import TikzConfig as TikzConfig
+from .config import TikzConfig
+from .colorbar import Colorbar
 from .figure import Figure as Figure
 from .state import main_name as main_name, next_show_num as next_show_num
 from .axes import Axes
@@ -12,6 +13,7 @@ ArrayLike = Union[Sequence[float], np.ndarray]
 ColorLike = Union[str, Sequence[float]]
 LineStyle = Literal["-", "--", "-.", ":", "solid", "dashed", "dashdot", "none", ""]
 MarkerStyle = Literal["o", "s", "^", "v", "x", "+", ".", "*", "None", ""]
+FontSize = Literal["xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large"]
 
 # --- Figure / Axes creation ---
 
@@ -238,15 +240,8 @@ def errorbar(self, x: ArrayLike = ..., y: ArrayLike = ..., yerr: Optional[ArrayL
         Mark size in pt
     """
     ...
-def scatter(
-    x: ArrayLike = ..., y: ArrayLike = ..., fmt: Optional[str] = ...,
-    *,
-    alpha: Optional[float] = ...,
-    color: Optional[ColorLike] = ..., c: Optional[ColorLike] = ...,
-    marker: Optional[MarkerStyle] = ...,
-    markersize: Optional[float] = ..., ms: Optional[float] = ...,
-    label: Optional[str] = ...
-) -> None:
+def scatter(self, x: ArrayLike = ..., y: ArrayLike = ..., fmt: Optional[str] = ..., *,alpha: Optional[float] = ..., color: Optional[Union[Sequence[ColorLike], ColorLike]] = ..., c: Optional[ColorLike] = ...,
+             marker: Optional[MarkerStyle] = ..., markersize: Optional[Union[Sequence[float], float]] = ..., s: Optional[Union[Sequence[float], float]] = ...,  label:Optional[str]=..., cmap: Optional[Union[str, Colorbar]], vmin: Optional[float] = ..., vmax: Optional[float] = ...) -> None:
     """
     Draw a scatter plot to the selected axis.
     
@@ -254,24 +249,23 @@ def scatter(
     ----------
     x,y : ArrayLike or float
         Datapoints
-
     fmt: str, optional
         Style
-
     alpha: float, optional
         Opacity
-
-    color or c: all matplotlib color formats (without X11/xkcd), optional
-        color of line and markers: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
-
+    color or c: array like or single: all matplotlib color formats (without X11/xkcd) or float for colormap, optional
+        color of line and markers: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible. Note that if the sequence if of the same length as x, it will be interpreted as color sequence for each point, otherwise it will be interpreted as a single color for all points.
     label: str, optional
         Legned entry
     
     marker: str, optional
         Marker type
-
-    markersize or ms: float, optional
-        Mark size in pt
+    markersize or s: ArrayLike or float, optional
+        Mark size in pt (or in 1/50 pt for s), if a sequence of same length as x, it will be interpreted as size for each point, otherwise it will be interpreted as a single size for all points.
+    cmap: str or Colorbar, optional
+        Colormap for scatter points, if color is given as float or sequence of floats. Can be a colormap name or a Colorbar object.
+    vmin, vmax: float, optional
+        Colorbar limits for scatter points, if color is given sequence of floats and cmap is given as string, otherwise ignored. If cmap is given as str and no vmin or vmax is provided, they will be set to the min and max of color sequence.
     """
     ...
 
@@ -367,6 +361,32 @@ def fill_between(
     """
     ...
 
+def text(self, x: float, y: float, s: str, color: Optional[ColorLike] = ..., c: Optional[ColorLike] = ..., fontsize: Optional[FontSize] = ..., size: Optional[FontSize] = ..., backgroundcolor: Optional[ColorLike] = ..., horizontalalignment: Optional[str] = ..., ha: Optional[str] = ..., verticalalignment: Optional[str] = ..., va: Optional[str] = ..., rotation: Optional[Union[float, str]] = ..., label: Optional[str] = ...) -> None:
+    """
+    Add text to the selected axis.
+    Parameters
+    ----------
+    x,y: float
+        Text position in axis coordinates
+    s: str
+        Text content (LaTeX format)
+    color or c: all matplotlib color formats (without X11/xkcd), optional
+        Text color: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+    fontsize or size: FontSize, optional
+        Font size
+    backgroundcolor: all matplotlib color formats (without X11/xkcd), optional
+        Background color of text box: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+    horizontalalignment or ha: {"center", "left", "right"}, optional
+        Horizontal alignment of text
+    verticalalignment or va: {"center", "top", "bottom"}, optional
+        Vertical alignment of text
+    rotation: float or {"vertical", "horizontal"}, optional
+        Rotation angle in degrees or preset rotation
+    label: str, optional
+    Legend entry
+    """
+    ...
+
 def loglog(self, x: ArrayLike = ..., y: ArrayLike = ..., base: Optional[float] = 10,  fmt: Optional[str] = ...,*, alpha: Optional[float] = ..., color: Optional[ColorLike] = ..., c: Optional[ColorLike] = ...,
              linestyle: Optional[LineStyle] = ..., ls: Optional[LineStyle] = ..., linewidth: Optional[float]= ..., lw: Optional[float] = ...,
              marker: Optional[MarkerStyle] = ..., markersize: Optional[float] = ..., ms: Optional[float] = ...) -> None:
@@ -399,6 +419,52 @@ def loglog(self, x: ArrayLike = ..., y: ArrayLike = ..., base: Optional[float] =
     """
     ...
 
+def hist(
+    self,
+    x: Union[ArrayLike, Sequence[ArrayLike]],
+    bins: int = ...,
+    density: bool = ...,
+    *,
+    cumulative: bool = ...,
+    orientation: Literal["horizontal","vertical"] = "vertical",
+    rwidth: Optional[float] = ...,
+    range: Optional[Tuple[float,float]] = ...,
+    color: Optional[ColorLike] = ...,
+    **kwargs: Any
+) -> None: 
+    """
+    Draw histogram to the selected axis.
+    """
+    ...
+def step(self, x: ArrayLike, y: ArrayLike, *args: Any, where: Literal["pre","post","mid"] = "pre", **kwargs: Any) -> None:
+    """
+    Draw a step plot to the selected axis.
+    Parameters
+    ----------
+    x,y : ArrayLike or float
+        Datapoints
+    where: {"pre", "post", "mid"}, default "pre"
+        Define where the steps should be placed: before the value (pre), after the value (post), or centered on the value (mid).
+    fmt: str, optional
+        Style
+    alpha: float, optional
+        Opacity
+    color or c: all matplotlib color formats (without X11/xkcd), optional
+        color of line and markers: RGB/RGBA (tuple), HEX (str), grayscale (float), single-char (str), name (str), default cycle ("CX", X int), none for invisible
+    label: str, optional
+        Legned entry
+    linestyle or ls: str, optional
+        Line style
+    linewidth or lw: float, optional
+        Line width in pt
+    
+    marker: str, optional
+        Marker type
+    markersize or ms: float, optional
+        Mark size in pt
+    """
+    ...
+
 def hlines(
     self,
     y: Union[float, Sequence[float]],

tikzplot42-0.3.3/src/tikzplot/texts.py

@@ -0,0 +1,119 @@
+from .colors import _tex_color
+
+class Text:
+    def __init__(self, ax, x, y, s, **kwargs):
+        self._axes = ax
+        self._x = x
+        self._y = y
+        self._s = s
+        self._kwargs = kwargs
+        self._color = False
+        self._opacity = 1
+        self._fsize = None
+        self._label = kwargs.get("label", None)
+        self._visible = True
+
+    _FONT_SIZES = {"xx-small": r"\tiny", "x-small": r"\scriptsize", "small": r"\footnotesize", "medium": r"\normalsize", "large": r"\large", "x-large": r"\Large", "xx-large": r"\LARGE"}
+
+    def match_color(self, input):
+            self._has_color = True
+            ccode, op = _tex_color(input)
+            if not isinstance(op, bool):
+                self._opacity = op
+            if isinstance(ccode, str):
+                return ccode
+            r,g,b=ccode
+            self._axes._add_col(r,g,b)
+            return f"c{r:.3f}{g:.3f}{b:.3f}".replace(".", "")
+
+    def _style_string(self):
+        output = []
+        if "color" in self._kwargs or "c" in self._kwargs:
+            self._color = self.match_color(self._kwargs.get("color") or self._kwargs.get("c"))
+        if "alpha" in self._kwargs:
+            self._opacity = self._kwargs["alpha"]
+        if "fontsize" in self._kwargs or "size" in self._kwargs:
+            size = self._kwargs.get('fontsize') or self._kwargs.get('size')
+            if size in self._FONT_SIZES:
+                self._fsize = self._FONT_SIZES[size]
+            else:
+                raise ValueError(f"Font size {size} not recognized. Valid sizes are: {', '.join(self._FONT_SIZES.keys())}")
+        if "backgroundcolor" in self._kwargs:
+            bg_color = self.match_color(self._kwargs["backgroundcolor"])
+            output.append(f"fill={bg_color}")
+        if "horizontalalignment" in self._kwargs or "ha" in self._kwargs:
+            ha = self._kwargs.get("horizontalalignment") or self._kwargs.get("ha")
+            if ha in {"center", "left", "right"}:
+                if ha in {"left", "right"}:
+                    output.append(ha)
+            else:
+                raise ValueError(f"Horizontal alignment {ha} not recognized. Valid options are: center, left, right.")
+        if "verticalalignment" in self._kwargs or "va" in self._kwargs:
+            va = self._kwargs.get("verticalalignment") or self._kwargs.get("va")
+            if va in {"center", "top", "bottom"}:
+                if va == "top":
+                    output.append("above")
+                elif va == "bottom":
+                    output.append("below")
+            else:
+                raise ValueError(f"Vertical alignment {va} not recognized. Valid options are: center, top, bottom.")
+        if "rotation" in self._kwargs:
+            if isinstance(self._kwargs["rotation"], str):
+                if self._kwargs["rotation"] == "vertical":
+                    output.append("rotate=90")
+                elif self._kwargs["rotation"] == "horizontal":
+                    pass
+            elif isinstance(self._kwargs["rotation"], (int, float)):
+                output.append(f"rotate={self._kwargs['rotation']}")
+            else:
+                raise ValueError(f"Rotation value {self._kwargs['rotation']} not recognized. Valid options are: vertical, horizontal, or a numeric angle.")
+        if self._opacity < 1:
+            output.insert(0,f"opacity={self._opacity}")
+        if self._color:
+            output.insert(0,f"color={self._color}")
+        return ", ".join(output)
+
+
+    def _to_tex(self, _):
+        if self._visible:
+            return f"\\node[{self._style_string()}] at (axis cs:{self._x},{self._y}) {{{self._fsize or ''}{self._s}}};"
+        else:
+            return ""
+    
+    def _set_label(self, label):
+        self._label = label
+
+    def _filter(self, which, value):
+        if (which == "xmin" and self._x < value) or (which == "xmax" and self._x > value) or (which == "ymin" and self._y < value) or (which == "ymax" and self._y > value):
+            self._visible = False
+    
+    def _get_erange(self, which):
+        if which in {"xmin", "xmax"}:
+            return self._x
+        elif which in {"ymin", "ymax"}:
+            return self._y
+    
+    def _num_points(self):
+        return 1
+    
+    def _reduce_points(self, max_points):
+        pass
+
+class Text3(Text):
+    def __init__(self, ax, x, y, z, s, **kwargs):
+        super().__init__(ax, x, y, s, **kwargs)
+        self._z = z
+
+    def _to_tex(self, _):
+        if self._visible:
+            return f"\\node[{self._style_string()}] at (axis cs:{self._x},{self._y},{self._z}) {{{self._fsize or ''}{self._s}}};"
+        else:
+            return ""
+    
+    def _get_erange(self, which):
+        if which in {"xmin", "xmax"}:
+            return self._x
+        elif which in {"ymin", "ymax"}:
+            return self._y
+        elif which in {"zmin", "zmax"}:
+            return self._z

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/src/tikzplot42.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplot42
-Version: 0.3.0
+Version: 0.3.3
 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
@@ -705,6 +705,10 @@ A clean version of PltToTikz, this time as Python package. Easy to use: only rep
 
 Please let me know if you find any bugs or unexpected behaviour. Examples may be found in repository under `tests/` directory.
 
+<p align="center">
+  <img src="https://github.com/ZanAmb/TikzPlot/blob/main/tests/demo.png" width="60%">
+</p>
+
 # Installation
 NEW: PyPI: `pip install tikzplot42`.
 Alternativley, download this package and install using: `pip install [path]`, where [path] is the path to the directory, containing `pyproject.toml`.
@@ -718,7 +722,8 @@ Instead of using `import matplotlib.pyplot (as plt)`, use `import tikzplot.plots
 - `\pgfplotsset{compat=1.18}` (may be lower, but compilation is not guaranteed),
 - `\usepgfplotslibrary{fillbetween}` (if you use fill-between plots),
 - `\usepgfplotslibrary{groupplots}` (recommended for best results, enabled by default, may be avoided by setting TikzConfig USE_GROUPPLOTS=False),
-- `\usepackage{xcolor}` (recommended for best colors, works without but needs change of TikzConfig USE_XCOLOR=False).
+- `\usepackage{xcolor}` (recommended for best colors, works without but needs change of TikzConfig USE_XCOLOR=False),
+- `\usepgfplotslibrary{polar}` required for polar axis.
 
 Export using `plt.savefig("example_graph.tex")` (recommended) or `plt.show()`.
 Then use the generated file as `\input{example_graph.tex}`.
@@ -735,7 +740,9 @@ Some basic plot commands are already implemented with commonly used arguments:
 - `fill-between()`,
 - `hlines()/vlines()`,
 - `historgam()`,
-- `imshow()`.
+- `step()`,
+- `imshow()`,
+- `text()`.
 
 #### Figures
 - `plt.figure()` (currently only to give you figure object or to set `figsize`),

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/src/tikzplot42.egg-info/SOURCES.txt

@@ -22,12 +22,14 @@ src/tikzplot/plots.pyi
 src/tikzplot/py.typed
 src/tikzplot/state.py
 src/tikzplot/state.pyi
+src/tikzplot/texts.py
 src/tikzplot42.egg-info/PKG-INFO
 src/tikzplot42.egg-info/SOURCES.txt
 src/tikzplot42.egg-info/dependency_links.txt
 src/tikzplot42.egg-info/requires.txt
 src/tikzplot42.egg-info/top_level.txt
 tests/test1.py
+tests/test10.py
 tests/test2.py
 tests/test3.py
 tests/test4.py

tikzplot42-0.3.3/tests/test10.py

@@ -0,0 +1,24 @@
+# Example from official matplotlib documentation
+
+import tikzplot.plots as plt
+import numpy as np
+#from tikzplot import Colorbar
+#from tikzplot import TikzConfig
+
+#TikzConfig.modifyParam(USE_GROUPPLOTS=False)
+
+# Fixing random state for reproducibility
+#np.random.seed(19680801)
+
+# Compute areas and colors
+N = 150
+r = 2 * np.random.rand(N)
+theta = 2 * np.pi * np.random.rand(N)
+area = 200 * r**2
+colors = theta
+
+fig = plt.figure(figsize=(6, 6))
+ax = fig.add_subplot(projection='polar')
+#cbar = Colorbar(cmap='hsv', lower=0, upper=max(theta))
+c = ax.scatter(theta, r, c=colors, s=area, cmap='hsv', alpha=0.75)
+plt.savefig("figure.tex")

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/tests/test2.py

@@ -9,7 +9,7 @@ fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2,2,sharex="row",sharey="row")
 ax1.set_xlim(left=2)
 ax1.plot(x,x)
 ax2.set_yscale("log")
-ax2.plot(x,y)
+ax2.step(x,y,".", ms=1,where="mid")
 ax3.plot(y,y)
 ax4.plot(y,x)
 ax1.set_xlabel(r"$x$")

{tikzplot42-0.3.0 → tikzplot42-0.3.3}/tests/test7.py

@@ -24,6 +24,7 @@ fig, axs = plt.subplots(3,2)
 ax = axs[0, 0]
 ax.plot(x, y, color="blue", lw=1.5, label="sin(x)")
 ax.plot(x, y2, ls="--", color="red", label="cos(x)")
+ax.text(1.5, 0.5, r"text $\alpha$", color="blue", ha="center", va="center", backgroundcolor="cyan", rotation=30)
 ax.grid()
 ax.legend(loc="upper right")