Merge pull request #376 from nschloe/new-format

specify format as .8e, not {:.8e}

Author: nschloe

test/helpers.py

@@ -33,7 +33,7 @@ def _unidiff_output(expected, actual):
 def assert_equality(plot, filename, **extra_get_tikz_code_args):
     plot()
     code = tikzplotlib.get_tikz_code(
-        include_disclaimer=False, float_format="{:.8g}", **extra_get_tikz_code_args
+        include_disclaimer=False, float_format=".8g", **extra_get_tikz_code_args
     )
     plt.close()
 

test/refresh_reference_files.py

@@ -24,7 +24,7 @@ def _main():
             spec.loader.exec_module(module)
             module.plot()
 
-            code = tpl.get_tikz_code(include_disclaimer=False, float_format="{:.8g}")
+            code = tpl.get_tikz_code(include_disclaimer=False, float_format=".8g")
             plt.close()
 
             tex_filename = filename[:-3] + "_reference.tex"

tikzplotlib/_axes.py

@@ -53,26 +53,24 @@ def __init__(self, data, obj):  # noqa: C901
             xlabel = _common_texification(xlabel)
             self.axis_options.append(f"xlabel={{{xlabel}}}")
             if xrotation != 0:
-                self.axis_options.append(
-                    "xlabel style={{rotate={}}}".format(xrotation - 90)
-                )
+                self.axis_options.append("xlabel style={{rotate={xrotation - 90)}}}")
         ylabel = obj.get_ylabel()
         yrotation = obj.yaxis.get_label().get_rotation()
         if ylabel:
             ylabel = _common_texification(ylabel)
             self.axis_options.append(f"ylabel={{{ylabel}}}")
             if yrotation != 90:
-                self.axis_options.append(
-                    "ylabel style={{rotate={}}}".format(yrotation - 90)
-                )
+                self.axis_options.append("ylabel style={{rotate={yrotation - 90}}}")
 
         # Axes limits.
         ff = data["float format"]
         xlim = list(obj.get_xlim())
+        xlim0, xlim1 = sorted(xlim)
         ylim = list(obj.get_ylim())
+        ylim0, ylim1 = sorted(ylim)
         # Sort the limits so make sure that the smaller of the two is actually *min.
-        self.axis_options.append(("xmin=" + ff + ", xmax=" + ff).format(*sorted(xlim)))
-        self.axis_options.append(("ymin=" + ff + ", ymax=" + ff).format(*sorted(ylim)))
+        self.axis_options.append(f"xmin={xlim0:{ff}}, xmax={xlim1:{ff}}")
+        self.axis_options.append(f"ymin={ylim0:{ff}}, ymax={ylim1:{ff}}")
         # When the axis is inverted add additional option
         if xlim != sorted(xlim):
             self.axis_options.append("x dir=reverse")
@@ -395,8 +393,8 @@ def _colorbar(self, colorbar, data):
             self.axis_options.append("colormap/" + mycolormap)
 
         ff = data["float format"]
-        self.axis_options.append(("point meta min=" + ff).format(limits[0]))
-        self.axis_options.append(("point meta max=" + ff).format(limits[1]))
+        self.axis_options.append(f"point meta min={limits[0]:{ff}}")
+        self.axis_options.append(f"point meta max={limits[1]:{ff}}")
 
         if colorbar_styles:
             self.axis_options.append(
@@ -417,7 +415,7 @@ def _subplot(self, obj, data):
                 # subplotspec geometry positioning is 0-based
                 self.subplot_index = geom[2] + 1
                 if "is_in_groupplot_env" not in data or not data["is_in_groupplot_env"]:
-                    group_style = ["group size={} by {}".format(geom[1], geom[0])]
+                    group_style = [f"group size={geom[1]} by {geom[0]}"]
                     group_style.extend(data["extra groupstyle options [base]"])
                     options = ["group style={{{}}}".format(", ".join(group_style))]
                     self.content.append(
@@ -460,12 +458,12 @@ def _get_label_rotation_and_horizontal_alignment(self, obj, data, x_or_y):
             values = []
 
             if any(tick_labels_rotation) != 0:
-                values.append("rotate={}".format(tick_labels_rotation[0]))
+                values.append(f"rotate={tick_labels_rotation[0]}")
 
             # Horizontal alignment will be ignored if no 'x/y tick label text width' has
             # been passed in the 'extra' parameter
             if tick_label_text_width:
-                values.append("align={}".format(tick_labels_horizontal_alignment[0]))
+                values.append(f"align={tick_labels_horizontal_alignment[0]}")
                 values.append(f"text width={tick_label_text_width}")
 
             if values:
@@ -476,7 +474,7 @@ def _get_label_rotation_and_horizontal_alignment(self, obj, data, x_or_y):
             values = []
 
             if tick_labels_rotation_same_value:
-                values.append("rotate={}".format(tick_labels_rotation[0]))
+                values.append("rotate={tick_labels_rotation[0]}")
             else:
                 values.append(
                     "rotate={{{},0}}[\\ticknum]".format(
@@ -488,20 +486,14 @@ def _get_label_rotation_and_horizontal_alignment(self, obj, data, x_or_y):
             # passed in the 'extra' parameter
             if tick_label_text_width:
                 if tick_labels_horizontal_alignment_same_value:
-                    values.append(
-                        "align={}".format(tick_labels_horizontal_alignment[0])
-                    )
+                    values.append(f"align={tick_labels_horizontal_alignment[0]}")
                     values.append(f"text width={tick_label_text_width}")
                 else:
                     for idx, x in enumerate(tick_labels_horizontal_alignment):
-                        label_style += "{}_tick_label_ha_{}/.initial = {}".format(
-                            x_or_y, idx, x
-                        )
+                        label_style += f"{x_or_y}_tick_label_ha_{idx}/.initial = {x}"
 
                     values.append(
-                        "align=\\pgfkeysvalueof{{/pgfplots/{}_tick_label_ha_\\ticknum}}".format(
-                            x_or_y
-                        )
+                        f"align=\\pgfkeysvalueof{{/pgfplots/{x_or_y}_tick_label_ha_\\ticknum}}"
                     )
                     values.append(f"text width={tick_label_text_width}")
 
@@ -587,7 +579,7 @@ def _get_ticks(data, xy, ticks, ticklabels):
             ff = data["float format"]
             axis_options.append(
                 "{}tick={{{}}}".format(
-                    xy, ",".join([ff.format(el) for el in pgfplots_ticks])
+                    xy, ",".join([f"{el:{ff}}" for el in pgfplots_ticks])
                 )
             )
         else:
@@ -726,11 +718,10 @@ def _handle_linear_segmented_color_map(cmap, data):
 
     color_changes = []
     ff = data["float format"]
-    for (k, x) in enumerate(X):
+    for k, x in enumerate(X):
         color_changes.append(
-            ("rgb({}{})=(" + ff + "," + ff + "," + ff + ")").format(
-                *((x, unit) + colors[k])
-            )
+            f"rgb({x}{unit})="
+            f"({colors[k][0]:{ff}},{colors[k][1]:{ff}},{colors[k][2]:{ff}})"
         )
 
     colormap_string = "{{mymap}}{{[1{}]\n  {}\n}}".format(
@@ -769,19 +760,15 @@ def _handle_listed_color_map(cmap, data):
     ff = data["float format"]
     if cmap.N is None or cmap.N == len(cmap.colors):
         colors = [
-            ("rgb({}{})=(" + ff + "," + ff + "," + ff + ")").format(
-                k, unit, rgb[0], rgb[1], rgb[2]
-            )
-            for (k, rgb) in enumerate(cmap.colors)
+            f"rgb({k}{unit})=({rgb[0]:{ff}},{rgb[1]:{ff}},{rgb[2]:{ff}})"
+            for k, rgb in enumerate(cmap.colors)
         ]
     else:
         reps = int(float(cmap.N) / len(cmap.colors) - 0.5) + 1
         repeated_cols = reps * cmap.colors
         colors = [
-            ("rgb({}{})=(" + ff + "," + ff + "," + ff + ")").format(
-                k, unit, rgb[0], rgb[1], rgb[2]
-            )
-            for (k, rgb) in enumerate(repeated_cols[: cmap.N])
+            "rgb({k}{unit})=({rgb[0]:{ff}},{rgb[1]:{ff}},{rgb[2]:{ff}})"
+            for k, rgb in enumerate(repeated_cols[: cmap.N])
         ]
     colormap_string = "{{mymap}}{{[1{}]\n {}\n}}".format(unit, ";\n  ".join(colors))
     is_custom_colormap = True

tikzplotlib/_color.py

@@ -68,7 +68,7 @@ def mpl_color2xcolor(data, matplotlib_color):
         # already accounted for by checking in available_colors above.
         if all(my_col[:3] == alpha * rgb) and 0.0 < alpha < 1.0:
             ff = data["float format"]
-            xcol = name + (f"!{ff}!black".format(alpha * 100))
+            xcol = name + f"!{alpha*100:{ff}}!black"
             return data, xcol, my_col
 
     # Lookup failed, add it to the custom list.

tikzplotlib/_files.py

@@ -3,7 +3,7 @@
 
 
 def _gen_filename(data, nb_key, ext):
-    name = data["base name"] + "-{:03d}{}".format(data[nb_key], ext)
+    name = data["base name"] + f"-{data[nb_key]:03d}{ext}"
     return os.path.join(data["output dir"], name), name
 
 

tikzplotlib/_hatches.py

@@ -106,7 +106,7 @@ def _mpl_hatch2pgfp_pattern(data, hatch, color_name, color_rgba):
         ff = data["float format"]
         # PGFPlots render patterns according to opacity fill.
         # This change is within the scope of the postaction
-        pattern_options.append(("fill opacity=" + ff).format(color_rgba[3]))
+        pattern_options.append(f"fill opacity={color_rgba[3]:{ff}}")
 
     # Add pattern as postaction to allow color fill and pattern together
     # https://tex.stackexchange.com/questions/24964/

tikzplotlib/_image.py

@@ -52,11 +52,8 @@ def draw_image(data, obj):
     # \includegraphics fails unexpectedly in some cases
     ff = data["float format"]
     content.append(
-        (
-            "\\addplot graphics [includegraphics cmd=\\pgfimage,"
-            "xmin=" + ff + ", xmax=" + ff + ", "
-            "ymin=" + ff + ", ymax=" + ff + "] {{{}}};\n"
-        ).format(*(extent + (rel_filepath,)))
+        "\\addplot graphics [includegraphics cmd=\\pgfimage,"
+        f"xmin={extent[0]:{ff}}, xmax={extent[1]:{ff}}, "
+        f"ymin={extent[2]:{ff}}, ymax={extent[3]:{ff}}] {{{rel_filepath}}};\n"
     )
-
     return data, content

tikzplotlib/_legend.py

@@ -45,9 +45,7 @@ def draw_legend(data, obj):
     ]
     if position:
         ff = data["float format"]
-        legend_style.append(
-            ("at={{(" + ff + "," + ff + ")}}").format(position[0], position[1])
-        )
+        legend_style.append(f"at={{({position[0]:{ff}},{position[1]:{ff}})}}")
     if anchor:
         legend_style.append(f"anchor={anchor}")
 

tikzplotlib/_line2d.py

@@ -143,7 +143,7 @@ def _marker(
         ff = data["float format"]
         # setting half size because pgfplots counts the radius/half-width
         pgf_size = 0.5 * mark_size
-        addplot_options.append(f"mark size={pgf_size:{ff[2:-1]}}")
+        addplot_options.append(f"mark size={pgf_size:{ff}}")
 
     mark_every = obj.get_markevery()
     if mark_every:
@@ -200,7 +200,7 @@ def _table(obj, data):  # noqa: C901
         xdata = xdata_alt
     elif isinstance(xdata_alt[0], str):
         data["current axes"].axis_options += [
-            "xtick={{{}}}".format(",".join([ff.format(x) for x in xdata])),
+            "xtick={{{}}}".format(",".join([f"{x:{ff}}" for x in xdata])),
             "xticklabels={{{}}}".format(",".join(xdata_alt)),
         ]
         xdata, ydata = transform_to_data_coordinates(obj, xdata, ydata)
@@ -237,7 +237,7 @@ def _table(obj, data):  # noqa: C901
 
     if isinstance(xdata[0], datetime.datetime):
         xdata = [date.strftime("%Y-%m-%d %H:%M") for date in xdata]
-        xformat = "{}"
+        xformat = ""
         col_sep = ","
         opts = ["header=false", "col sep=comma"]
         data["current axes"].axis_options.append("date coordinates in=x")
@@ -269,26 +269,16 @@ def _table(obj, data):  # noqa: C901
         content.append("table {%\n")
 
     plot_table = []
+    table_row_sep = data["table_row_sep"]
+    ydata[ydata_mask] = numpy.nan
     if any(ydata_mask):
         # matplotlib jumps at masked images, while PGFPlots by default interpolates.
         # Hence, if we have a masked plot, make sure that PGFPlots jumps as well.
         if "unbounded coords=jump" not in data["current axes"].axis_options:
             data["current axes"].axis_options.append("unbounded coords=jump")
 
-        for (x, y, is_masked) in zip(xdata, ydata, ydata_mask):
-            if is_masked:
-                plot_table.append(
-                    (xformat + col_sep + "nan" + data["table_row_sep"]).format(x)
-                )
-            else:
-                plot_table.append(
-                    (xformat + col_sep + ff + data["table_row_sep"]).format(x, y)
-                )
-    else:
-        for x, y in zip(xdata, ydata):
-            plot_table.append(
-                (xformat + col_sep + ff + data["table_row_sep"]).format(x, y)
-            )
+    for x, y in zip(xdata, ydata):
+        plot_table.append(f"{x:{xformat}}{col_sep}{y:{ff}}{table_row_sep}")
 
     if data["externalize tables"]:
         filename, rel_filepath = _files.new_filename(data, "table", ".tsv")

tikzplotlib/_patch.py

@@ -139,15 +139,12 @@ def _draw_rectangle(data, obj, draw_options):
     left_lower_x = obj.get_x()
     left_lower_y = obj.get_y()
     ff = data["float format"]
+    do = ",".join(draw_options)
+    right_upper_x = left_lower_x + obj.get_width()
+    right_upper_y = left_lower_y + obj.get_height()
     cont = (
-        "\\draw[{}] (axis cs:" + ff + "," + ff + ") "
-        "rectangle (axis cs:" + ff + "," + ff + ");\n"
-    ).format(
-        ",".join(draw_options),
-        left_lower_x,
-        left_lower_y,
-        left_lower_x + obj.get_width(),
-        left_lower_y + obj.get_height(),
+        f"\\draw[{do}] (axis cs:{left_lower_x:{ff}},{left_lower_y:{ff}}) "
+        f"rectangle (axis cs:{right_upper_x:{ff}},{right_upper_y:{ff}});\n"
     )
 
     if label != "_nolegend_" and label not in data["rectangle_legends"]:
@@ -169,21 +166,15 @@ def _draw_ellipse(data, obj, draw_options):
     ff = data["float format"]
 
     if obj.angle != 0:
-        fmt = "rotate around={{" + ff + ":(axis cs:" + ff + "," + ff + ")}}"
-        draw_options.append(fmt.format(obj.angle, x, y))
+        draw_options.append(
+            f"rotate around={{{obj.angle:{ff}}:(axis cs:{x:{ff}},{y:{ff}})}}"
+        )
 
+    do = ",".join(draw_options)
     content = (
-        "\\draw[{}] (axis cs:"
-        + ff
-        + ","
-        + ff
-        + ") ellipse ("
-        + ff
-        + " and "
-        + ff
-        + ");\n"
-    ).format(",".join(draw_options), x, y, 0.5 * obj.width, 0.5 * obj.height)
-
+        f"\\draw[{do}] (axis cs:{x:{ff}},{y:{ff}}) ellipse "
+        f"({0.5 * obj.width:{ff}} and {0.5 * obj.height:{ff}});\n"
+    )
     content += _patch_legend(obj, draw_options, "area legend")
 
     return data, content
@@ -194,11 +185,11 @@ def _draw_circle(data, obj, draw_options):
     """
     x, y = obj.center
     ff = data["float format"]
+    do = ",".join(draw_options)
     content = (
-        "\\draw[{}] (axis cs:" + ff + "," + ff + ") circle (" + ff + ");\n"
-    ).format(",".join(draw_options), x, y, obj.get_radius())
+        f"\\draw[{do}] (axis cs:{x:{ff}},{y:{ff}}) circle ({obj.get_radius():{ff}});\n"
+    )
     content += _patch_legend(obj, draw_options, "area legend")
-
     return data, content
 
 
@@ -207,9 +198,11 @@ def _draw_fancy_arrow(data, obj, draw_options):
     ff = data["float format"]
     if obj._posA_posB is not None:
         posA, posB = obj._posA_posB
-        content = "\\draw[{{}}] (axis cs:{ff},{ff}) -- (axis cs:{ff},{ff});\n".format(
-            ff=ff
-        ).format(",".join(style), *posA, *posB)
+        do = ",".join(style)
+        content = (
+            f"\\draw[{do}] (axis cs:{posA[0]:{ff}},{posA[1]:{ff}}) -- "
+            f"(axis cs:{posB[0]:{ff}},{posB[1]:{ff}});\n"
+        )
     else:
         data, content, _, _ = mypath.draw_path(
             data, obj._path_original, draw_options=draw_options + style