scitex 2.5.0__py3-none-any.whl → 2.7.3__py3-none-any.whl

scitex/plt/styles/_plot_postprocess.py

@@ -52,25 +52,25 @@ def apply_plot_postprocess(method_name, result, ax, kwargs, args=None):
     _apply_tick_locator(ax)
 
     # Method-specific post-processing
-    if method_name == 'pie' and result is not None:
+    if method_name == "pie" and result is not None:
         _postprocess_pie(result)
-    elif method_name == 'stem' and result is not None:
+    elif method_name == "stem" and result is not None:
         _postprocess_stem(result)
-    elif method_name == 'violinplot' and result is not None:
+    elif method_name == "violinplot" and result is not None:
         _postprocess_violin(result, ax, kwargs, args)
-    elif method_name == 'boxplot' and result is not None:
+    elif method_name == "boxplot" and result is not None:
         _postprocess_boxplot(result, ax)
-    elif method_name == 'scatter' and result is not None:
+    elif method_name == "scatter" and result is not None:
         _postprocess_scatter(result, kwargs)
-    elif method_name == 'bar' and result is not None:
+    elif method_name == "bar" and result is not None:
         _postprocess_bar(result, ax, kwargs)
-    elif method_name == 'barh' and result is not None:
+    elif method_name == "barh" and result is not None:
         _postprocess_barh(result, ax, kwargs)
-    elif method_name == 'errorbar' and result is not None:
+    elif method_name == "errorbar" and result is not None:
         _postprocess_errorbar(result)
-    elif method_name == 'hist' and result is not None:
+    elif method_name == "hist" and result is not None:
         _postprocess_hist(result, ax)
-    elif method_name == 'fill_between' and result is not None:
+    elif method_name == "fill_between" and result is not None:
         _postprocess_fill_between(result, kwargs)
 
     return result
@@ -117,10 +117,11 @@ def _apply_tick_locator(ax):
     min_n_ticks=3 ensures at least 3 ticks (never 2).
     """
     try:
+
         def is_categorical_axis(axis):
             if isinstance(axis.converter, StrCategoryConverter):
                 return True
-            if hasattr(axis, 'units') and isinstance(axis.units, UnitData):
+            if hasattr(axis, "units") and isinstance(axis.units, UnitData):
                 return True
             if isinstance(axis.get_major_locator(), FixedLocator):
                 return True
@@ -128,12 +129,16 @@ def _apply_tick_locator(ax):
 
         if not is_categorical_axis(ax.xaxis):
             ax.xaxis.set_major_locator(
-                MaxNLocator(nbins=DEFAULT_N_TICKS, min_n_ticks=3, integer=False, prune=None)
+                MaxNLocator(
+                    nbins=DEFAULT_N_TICKS, min_n_ticks=3, integer=False, prune=None
+                )
             )
 
         if not is_categorical_axis(ax.yaxis):
             ax.yaxis.set_major_locator(
-                MaxNLocator(nbins=DEFAULT_N_TICKS, min_n_ticks=3, integer=False, prune=None)
+                MaxNLocator(
+                    nbins=DEFAULT_N_TICKS, min_n_ticks=3, integer=False, prune=None
+                )
             )
     except Exception:
         pass
@@ -155,8 +160,8 @@ def _postprocess_stem(result):
     """Apply styling for stem plots."""
     baseline = result.baseline
     if baseline is not None:
-        baseline.set_color('black')
-        baseline.set_linestyle('--')
+        baseline.set_color("black")
+        baseline.set_linestyle("--")
 
 
 def _postprocess_errorbar(result):
@@ -170,16 +175,31 @@ def _postprocess_errorbar(result):
 
     # Custom handler that shows only a simple line for errorbar
     class SimpleLineHandler(HandlerErrorbar):
-        def create_artists(self, legend, orig_handle, xdescent, ydescent,
-                          width, height, fontsize, trans):
+        def create_artists(
+            self,
+            legend,
+            orig_handle,
+            xdescent,
+            ydescent,
+            width,
+            height,
+            fontsize,
+            trans,
+        ):
             # Use HandlerLine2D to create just a line
             line_handler = HandlerLine2D()
             # Get the data line from the ErrorbarContainer
             data_line = orig_handle[0]
             if data_line is not None:
                 return line_handler.create_artists(
-                    legend, data_line, xdescent, ydescent,
-                    width, height, fontsize, trans
+                    legend,
+                    data_line,
+                    xdescent,
+                    ydescent,
+                    width,
+                    height,
+                    fontsize,
+                    trans,
                 )
             return []
 
@@ -191,31 +211,40 @@ def _postprocess_violin(result, ax, kwargs, args):
     """Apply styling for violin plots with optional boxplot overlay."""
     # Get scitex palette for coloring
     from scitex.plt.color._PARAMS import HEX
-    palette = [HEX['blue'], HEX['red'], HEX['green'], HEX['yellow'],
-               HEX['purple'], HEX['orange'], HEX['lightblue'], HEX['pink']]
 
-    if 'bodies' in result:
-        for i, body in enumerate(result['bodies']):
+    palette = [
+        HEX["blue"],
+        HEX["red"],
+        HEX["green"],
+        HEX["yellow"],
+        HEX["purple"],
+        HEX["orange"],
+        HEX["lightblue"],
+        HEX["pink"],
+    ]
+
+    if "bodies" in result:
+        for i, body in enumerate(result["bodies"]):
             body.set_facecolor(palette[i % len(palette)])
-            body.set_edgecolor('black')
+            body.set_edgecolor("black")
             body.set_linewidth(mm_to_pt(DEFAULT_LINE_WIDTH_MM))
             body.set_alpha(1.0)
 
     # Add boxplot overlay by default (disable with boxplot=False)
-    add_boxplot = kwargs.pop('boxplot', True)
+    add_boxplot = kwargs.pop("boxplot", True)
     if add_boxplot and args:
         try:
             # Get data from first positional argument
             data = args[0]
             # Get positions if specified, otherwise use default
-            positions = kwargs.get('positions', None)
+            positions = kwargs.get("positions", None)
             if positions is None:
                 positions = range(1, len(data) + 1)
 
             # Calculate boxplot width dynamically from violin width
             # Get violin width from kwargs or use matplotlib default (0.5)
-            violin_widths = kwargs.get('widths', 0.5)
-            if hasattr(violin_widths, '__iter__'):
+            violin_widths = kwargs.get("widths", 0.5)
+            if hasattr(violin_widths, "__iter__"):
                 violin_widths = violin_widths[0] if len(violin_widths) > 0 else 0.5
             # Boxplot width = 20% of violin width
             boxplot_widths = violin_widths * 0.2
@@ -226,7 +255,7 @@ def _postprocess_violin(result, ax, kwargs, args):
 
             # Call matplotlib's boxplot directly to avoid recursive post-processing
             # which would override our gray styling with the default blue
-            if hasattr(ax, '_axes_mpl'):
+            if hasattr(ax, "_axes_mpl"):
                 mpl_ax = ax._axes_mpl
             else:
                 mpl_ax = ax
@@ -241,28 +270,29 @@ def _postprocess_violin(result, ax, kwargs, args):
             # Style the boxplot: scitex gray fill with black edges for visibility
             # Set high z-order so boxplot appears on top of violin bodies
             from scitex.plt.color._PARAMS import HEX
+
             boxplot_zorder = 10
-            for box in bp.get('boxes', []):
-                box.set_facecolor(HEX['gray'])  # Scitex gray fill
-                box.set_edgecolor('black')
+            for box in bp.get("boxes", []):
+                box.set_facecolor(HEX["gray"])  # Scitex gray fill
+                box.set_edgecolor("black")
                 box.set_alpha(1.0)
                 box.set_linewidth(line_width)
                 box.set_zorder(boxplot_zorder)
-            for median in bp.get('medians', []):
-                median.set_color('black')  # Black median line
+            for median in bp.get("medians", []):
+                median.set_color("black")  # Black median line
                 median.set_linewidth(line_width)  # 0.2mm thickness
                 median.set_zorder(boxplot_zorder + 1)
-            for whisker in bp.get('whiskers', []):
-                whisker.set_color('black')
+            for whisker in bp.get("whiskers", []):
+                whisker.set_color("black")
                 whisker.set_linewidth(line_width)
                 whisker.set_zorder(boxplot_zorder)
-            for cap in bp.get('caps', []):
-                cap.set_color('black')
+            for cap in bp.get("caps", []):
+                cap.set_color("black")
                 cap.set_linewidth(line_width)
                 cap.set_zorder(boxplot_zorder)
-            for flier in bp.get('fliers', []):
-                flier.set_markerfacecolor('none')  # No fill (open circles)
-                flier.set_markeredgecolor('black')
+            for flier in bp.get("fliers", []):
+                flier.set_markerfacecolor("none")  # No fill (open circles)
+                flier.set_markeredgecolor("black")
                 flier.set_markersize(marker_size)  # 0.8mm
                 flier.set_markeredgewidth(line_width)  # 0.2mm
                 flier.set_zorder(boxplot_zorder + 2)
@@ -274,13 +304,14 @@ def _postprocess_boxplot(result, ax):
     """Apply styling for boxplots (standalone, not violin overlay)."""
     # Use the centralized style_boxplot function for consistent styling
     from scitex.plt.ax import style_boxplot
+
     style_boxplot(result)
 
     # Cap width: 33% of box width
-    if 'caps' in result and 'boxes' in result and len(result['boxes']) > 0:
+    if "caps" in result and "boxes" in result and len(result["boxes"]) > 0:
         try:
-            cap_width_pts = _calculate_cap_width_from_box(result['boxes'][0], ax)
-            for cap in result['caps']:
+            cap_width_pts = _calculate_cap_width_from_box(result["boxes"][0], ax)
+            for cap in result["caps"]:
                 cap.set_markersize(cap_width_pts)
         except Exception:
             pass
@@ -289,9 +320,9 @@ def _postprocess_boxplot(result, ax):
 def _postprocess_scatter(result, kwargs):
     """Apply styling for scatter plots."""
     # Apply default 0.8mm marker size if 's' not specified
-    if 's' not in kwargs:
+    if "s" not in kwargs:
         size_pt = mm_to_pt(DEFAULT_MARKER_SIZE_MM)
-        marker_area = size_pt ** 2
+        marker_area = size_pt**2
         result.set_sizes([marker_area])
 
 
@@ -306,18 +337,18 @@ def _postprocess_hist(result, ax):
     if len(result) >= 3:
         patches = result[2]
         # Handle both single histogram and stacked histograms
-        if hasattr(patches, '__iter__'):
+        if hasattr(patches, "__iter__"):
             for patch_group in patches:
-                if hasattr(patch_group, '__iter__'):
+                if hasattr(patch_group, "__iter__"):
                     for patch in patch_group:
-                        patch.set_edgecolor('black')
+                        patch.set_edgecolor("black")
                         patch.set_linewidth(line_width)
                         # Ensure alpha is at least 0.7 for visibility
                         if patch.get_alpha() is None or patch.get_alpha() < 0.7:
                             patch.set_alpha(1.0)
                 else:
                     # Single patch
-                    patch_group.set_edgecolor('black')
+                    patch_group.set_edgecolor("black")
                     patch_group.set_linewidth(line_width)
                     if patch_group.get_alpha() is None or patch_group.get_alpha() < 0.7:
                         patch_group.set_alpha(1.0)
@@ -334,29 +365,38 @@ def _postprocess_fill_between(result, kwargs):
         line_width = mm_to_pt(DEFAULT_LINE_WIDTH_MM)
 
         # Only set edge if not already specified
-        if 'edgecolor' not in kwargs and 'ec' not in kwargs:
-            result.set_edgecolor('none')
+        if "edgecolor" not in kwargs and "ec" not in kwargs:
+            result.set_edgecolor("none")
 
         # Ensure alpha is reasonable (default 0.3 is common for fill_between)
-        if 'alpha' not in kwargs:
+        if "alpha" not in kwargs:
             result.set_alpha(0.3)
 
 
 def _postprocess_bar(result, ax, kwargs):
     """Apply styling for bar plots with colors and error bars."""
     # Get scitex palette for coloring (only if color not explicitly set)
-    if 'color' not in kwargs and 'c' not in kwargs:
+    if "color" not in kwargs and "c" not in kwargs:
         from scitex.plt.color._PARAMS import HEX
-        palette = [HEX['blue'], HEX['red'], HEX['green'], HEX['yellow'],
-                   HEX['purple'], HEX['orange'], HEX['lightblue'], HEX['pink']]
+
+        palette = [
+            HEX["blue"],
+            HEX["red"],
+            HEX["green"],
+            HEX["yellow"],
+            HEX["purple"],
+            HEX["orange"],
+            HEX["lightblue"],
+            HEX["pink"],
+        ]
 
         line_width = mm_to_pt(DEFAULT_LINE_WIDTH_MM)
         for i, patch in enumerate(result.patches):
             patch.set_facecolor(palette[i % len(palette)])
-            patch.set_edgecolor('black')
+            patch.set_edgecolor("black")
             patch.set_linewidth(line_width)
 
-    if 'yerr' not in kwargs or kwargs['yerr'] is None:
+    if "yerr" not in kwargs or kwargs["yerr"] is None:
         return
 
     try:
@@ -376,14 +416,14 @@ def _postprocess_bar(result, ax, kwargs):
             # Adjust cap width to 33% of bar width
             if len(result.patches) > 0:
                 cap_width_pts = _calculate_cap_width_from_bar(
-                    result.patches[0], ax, 'width'
+                    result.patches[0], ax, "width"
                 )
                 for cap in caplines[1:]:
                     cap.set_markersize(cap_width_pts)
 
         # Make error bar lines one-sided
         barlinecols = lines[2]
-        _make_errorbar_one_sided(barlinecols, 'vertical')
+        _make_errorbar_one_sided(barlinecols, "vertical")
     except Exception:
         pass
 
@@ -391,18 +431,27 @@ def _postprocess_bar(result, ax, kwargs):
 def _postprocess_barh(result, ax, kwargs):
     """Apply styling for horizontal bar plots with colors and error bars."""
     # Get scitex palette for coloring (only if color not explicitly set)
-    if 'color' not in kwargs and 'c' not in kwargs:
+    if "color" not in kwargs and "c" not in kwargs:
         from scitex.plt.color._PARAMS import HEX
-        palette = [HEX['blue'], HEX['red'], HEX['green'], HEX['yellow'],
-                   HEX['purple'], HEX['orange'], HEX['lightblue'], HEX['pink']]
+
+        palette = [
+            HEX["blue"],
+            HEX["red"],
+            HEX["green"],
+            HEX["yellow"],
+            HEX["purple"],
+            HEX["orange"],
+            HEX["lightblue"],
+            HEX["pink"],
+        ]
 
         line_width = mm_to_pt(DEFAULT_LINE_WIDTH_MM)
         for i, patch in enumerate(result.patches):
             patch.set_facecolor(palette[i % len(palette)])
-            patch.set_edgecolor('black')
+            patch.set_edgecolor("black")
             patch.set_linewidth(line_width)
 
-    if 'xerr' not in kwargs or kwargs['xerr'] is None:
+    if "xerr" not in kwargs or kwargs["xerr"] is None:
         return
 
     try:
@@ -422,14 +471,14 @@ def _postprocess_barh(result, ax, kwargs):
             # Adjust cap width to 33% of bar height
             if len(result.patches) > 0:
                 cap_width_pts = _calculate_cap_width_from_bar(
-                    result.patches[0], ax, 'height'
+                    result.patches[0], ax, "height"
                 )
                 for cap in caplines[1:]:
                     cap.set_markersize(cap_width_pts)
 
         # Make error bar lines one-sided
         barlinecols = lines[2]
-        _make_errorbar_one_sided(barlinecols, 'horizontal')
+        _make_errorbar_one_sided(barlinecols, "horizontal")
     except Exception:
         pass
 
@@ -440,36 +489,36 @@ def _postprocess_barh(result, ax, kwargs):
 def _calculate_cap_width_from_box(box, ax):
     """Calculate cap width as 33% of box width in points."""
     # Get box width from path
-    if hasattr(box, 'get_path'):
+    if hasattr(box, "get_path"):
         path = box.get_path()
         vertices = path.vertices
         x_coords = vertices[:, 0]
         box_width_data = x_coords.max() - x_coords.min()
-    elif hasattr(box, 'get_xdata'):
+    elif hasattr(box, "get_xdata"):
         x_data = box.get_xdata()
         box_width_data = max(x_data) - min(x_data)
     else:
         box_width_data = 0.5  # Default
 
-    return _data_width_to_points(box_width_data, ax, 'x') * CAP_WIDTH_RATIO
+    return _data_width_to_points(box_width_data, ax, "x") * CAP_WIDTH_RATIO
 
 
 def _calculate_cap_width_from_bar(patch, ax, dimension):
     """Calculate cap width as 33% of bar width/height in points."""
-    if dimension == 'width':
+    if dimension == "width":
         bar_size = patch.get_width()
-        return _data_width_to_points(bar_size, ax, 'x') * CAP_WIDTH_RATIO
+        return _data_width_to_points(bar_size, ax, "x") * CAP_WIDTH_RATIO
     else:  # height
         bar_size = patch.get_height()
-        return _data_width_to_points(bar_size, ax, 'y') * CAP_WIDTH_RATIO
+        return _data_width_to_points(bar_size, ax, "y") * CAP_WIDTH_RATIO
 
 
-def _data_width_to_points(data_size, ax, axis='x'):
+def _data_width_to_points(data_size, ax, axis="x"):
     """Convert a data-space size to points."""
     fig = ax.get_figure()
     bbox = ax.get_position()
 
-    if axis == 'x':
+    if axis == "x":
         ax_size_inches = bbox.width * fig.get_figwidth()
         lim = ax.get_xlim()
     else:
@@ -487,7 +536,7 @@ def _make_errorbar_one_sided(barlinecols, direction):
         return
 
     for lc in barlinecols:
-        if not hasattr(lc, 'get_segments'):
+        if not hasattr(lc, "get_segments"):
             continue
 
         segs = lc.get_segments()
@@ -496,7 +545,7 @@ def _make_errorbar_one_sided(barlinecols, direction):
             if len(seg) < 2:
                 continue
 
-            if direction == 'vertical':
+            if direction == "vertical":
                 # Keep upper half
                 bottom_y = min(seg[0][1], seg[1][1])
                 top_y = max(seg[0][1], seg[1][1])

scitex/plt/styles/presets.py

@@ -33,9 +33,20 @@ Usage:
 """
 
 __all__ = [
-    "SCITEX_STYLE", "STYLE",
-    "load_style", "save_style", "set_style", "get_style",
+    "SCITEX_STYLE",
+    "STYLE",
+    "load_style",
+    "save_style",
+    "set_style",
+    "get_style",
     "resolve_style_value",
+    # DPI utilities
+    "get_default_dpi",
+    "get_display_dpi",
+    "get_preview_dpi",
+    "DPI_SAVE",
+    "DPI_DISPLAY",
+    "DPI_PREVIEW",
 ]
 
 from pathlib import Path
@@ -54,12 +65,19 @@ def _get_config(yaml_path: Optional[Path] = None) -> PriorityConfig:
     global _config
     if _config is None or yaml_path:
         yaml = scitex.io.load(yaml_path or _STYLE_FILE)
-        flat = {f"{k}.{k2}": v2 for k, v in yaml.items() if isinstance(v, dict) and k != "presets" for k2, v2 in v.items()}
+        flat = {
+            f"{k}.{k2}": v2
+            for k, v in yaml.items()
+            if isinstance(v, dict) and k != "presets"
+            for k2, v2 in v.items()
+        }
         _config = PriorityConfig(flat, env_prefix="SCITEX_PLT_", auto_uppercase=True)
     return _config
 
 
-def resolve_style_value(key: str, direct_val: Any = None, default: Any = None, type: type = float) -> Any:
+def resolve_style_value(
+    key: str, direct_val: Any = None, default: Any = None, type: type = float
+) -> Any:
     """Resolve value with priority: direct → env → yaml → default.
 
     Key format: 'axes.width_mm' - dots for YAML hierarchy, underscores for env vars.
@@ -68,30 +86,115 @@ def resolve_style_value(key: str, direct_val: Any = None, default: Any = None, t
     return _get_config().resolve(key, direct_val, default, type)
 
 
+# =============================================================================
+# DPI Resolution - Central Source of Truth
+# =============================================================================
+#
+# DPI Priority Chain:
+#   1. Bundle's geometry_px.json (highest - existing figure's actual DPI)
+#   2. User override / session setting
+#   3. SCITEX_STYLE.yaml output.dpi (project default)
+#   4. Hardcoded fallback (only if config missing)
+#
+# Usage:
+#   from scitex.plt.styles import get_default_dpi, DPI_SAVE
+#
+#   # For saving figures (publication quality)
+#   fig.savefig("out.png", dpi=get_default_dpi())
+#
+#   # For display/preview (lower resolution)
+#   fig.savefig("preview.png", dpi=get_display_dpi())
+#
+#   # When loading from bundle, use bundle's DPI:
+#   dpi = bundle.get("geometry", {}).get("dpi") or get_default_dpi()
+#
+
+# Fallback values (only used if config unavailable)
+_FALLBACK_DPI_SAVE = 300
+_FALLBACK_DPI_DISPLAY = 100
+_FALLBACK_DPI_PREVIEW = 150
+
+
+def get_default_dpi() -> int:
+    """Get default DPI for saving/publication from config.
+
+    Priority: SCITEX_STYLE.yaml → env var → fallback 300
+
+    Returns:
+        int: DPI value for publication-quality output
+    """
+    return int(resolve_style_value("output.dpi", None, _FALLBACK_DPI_SAVE, int))
+
+
+def get_display_dpi() -> int:
+    """Get DPI for screen display (lower resolution for speed).
+
+    Returns approximately 1/3 of save DPI, minimum 100.
+
+    Returns:
+        int: DPI value for screen display
+    """
+    save_dpi = get_default_dpi()
+    return max(_FALLBACK_DPI_DISPLAY, save_dpi // 3)
+
+
+def get_preview_dpi() -> int:
+    """Get DPI for editor previews and thumbnails.
+
+    Returns 1/2 of save DPI, clamped between 100-200.
+
+    Returns:
+        int: DPI value for previews
+    """
+    save_dpi = get_default_dpi()
+    return max(_FALLBACK_DPI_DISPLAY, min(200, save_dpi // 2))
+
+
+# Module-level constants (evaluated at import time)
+# Use functions for dynamic resolution, constants for static defaults
+DPI_SAVE = _FALLBACK_DPI_SAVE      # Use get_default_dpi() for dynamic
+DPI_DISPLAY = _FALLBACK_DPI_DISPLAY
+DPI_PREVIEW = _FALLBACK_DPI_PREVIEW
+
+
 def load_style(path: Optional[Union[str, Path]] = None) -> Dict[str, Any]:
     """Load style from YAML as subplots kwargs."""
     cfg = _get_config(Path(path) if path else None)
     g = lambda k, d, t=float: cfg.resolve(k, None, d, t)
     return {
-        "axes_width_mm": g("axes.width_mm", 40), "axes_height_mm": g("axes.height_mm", 28),
+        "axes_width_mm": g("axes.width_mm", 40),
+        "axes_height_mm": g("axes.height_mm", 28),
         "axes_thickness_mm": g("axes.thickness_mm", 0.2),
-        "margin_left_mm": g("margins.left_mm", 20), "margin_right_mm": g("margins.right_mm", 20),
-        "margin_bottom_mm": g("margins.bottom_mm", 20), "margin_top_mm": g("margins.top_mm", 20),
-        "space_w_mm": g("spacing.horizontal_mm", 8), "space_h_mm": g("spacing.vertical_mm", 10),
-        "tick_length_mm": g("ticks.length_mm", 0.8), "tick_thickness_mm": g("ticks.thickness_mm", 0.2),
+        "margin_left_mm": g("margins.left_mm", 20),
+        "margin_right_mm": g("margins.right_mm", 20),
+        "margin_bottom_mm": g("margins.bottom_mm", 20),
+        "margin_top_mm": g("margins.top_mm", 20),
+        "space_w_mm": g("spacing.horizontal_mm", 8),
+        "space_h_mm": g("spacing.vertical_mm", 10),
+        "tick_length_mm": g("ticks.length_mm", 0.8),
+        "tick_thickness_mm": g("ticks.thickness_mm", 0.2),
         "n_ticks": g("ticks.n_ticks", 4, int),
-        "trace_thickness_mm": g("lines.trace_mm", 0.2), "errorbar_thickness_mm": g("lines.errorbar_mm", 0.2),
-        "errorbar_cap_width_mm": g("lines.errorbar_cap_mm", 0.8), "bar_edge_thickness_mm": g("lines.bar_edge_mm", 0.2),
+        "trace_thickness_mm": g("lines.trace_mm", 0.2),
+        "errorbar_thickness_mm": g("lines.errorbar_mm", 0.2),
+        "errorbar_cap_width_mm": g("lines.errorbar_cap_mm", 0.8),
+        "bar_edge_thickness_mm": g("lines.bar_edge_mm", 0.2),
         "kde_line_thickness_mm": g("lines.kde_mm", 0.2),
-        "scatter_size_mm": g("markers.scatter_mm", 0.8), "marker_size_mm": g("markers.size_mm", 0.8),
+        "scatter_size_mm": g("markers.scatter_mm", 0.8),
+        "marker_size_mm": g("markers.size_mm", 0.8),
         "font_family": g("fonts.family", "Arial", str),
-        "axis_font_size_pt": g("fonts.axis_label_pt", 7), "tick_font_size_pt": g("fonts.tick_label_pt", 7),
-        "title_font_size_pt": g("fonts.title_pt", 8), "suptitle_font_size_pt": g("fonts.suptitle_pt", 8),
-        "legend_font_size_pt": g("fonts.legend_pt", 6), "annotation_font_size_pt": g("fonts.annotation_pt", 6),
-        "label_pad_pt": g("padding.label_pt", 0.5), "tick_pad_pt": g("padding.tick_pt", 2.0),
+        "axis_font_size_pt": g("fonts.axis_label_pt", 7),
+        "tick_font_size_pt": g("fonts.tick_label_pt", 7),
+        "title_font_size_pt": g("fonts.title_pt", 8),
+        "suptitle_font_size_pt": g("fonts.suptitle_pt", 8),
+        "legend_font_size_pt": g("fonts.legend_pt", 6),
+        "annotation_font_size_pt": g("fonts.annotation_pt", 6),
+        "label_pad_pt": g("padding.label_pt", 0.5),
+        "tick_pad_pt": g("padding.tick_pt", 2.0),
         "title_pad_pt": g("padding.title_pt", 1.0),
-        "dpi": g("output.dpi", 300, int), "transparent": g("output.transparent", True, bool),
-        "auto_scale_axes": g("behavior.auto_scale_axes", True, bool), "mode": "publication",
+        "dpi": g("output.dpi", 300, int),
+        "transparent": g("output.transparent", True, bool),
+        "auto_scale_axes": g("behavior.auto_scale_axes", True, bool),
+        "mode": "publication",
     }