Merge branch 'main' into rm/fix-step-plot

Author: camdecoster

CHANGELOG.md

@@ -5,9 +5,11 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ## Unreleased
 
 ### Fixed
+- Fix `mpl_to_plotly` tick marker mirroring, axis positioning, and trace visibility for twinned and overlaid subplots (such as `twinx` and `twiny`) [[#5310](https://github.com/plotly/plotly.py/pull/5310)], with thanks to @robertoffmoura for the contribution!
 - Fix concurrent first access to lazily initialized graph object properties, which could raise `ValueError("Invalid value")` [[#5691](https://github.com/plotly/plotly.py/pull/5691)], with thanks to @hb1915 for the contribution!
 - Fix `mpl_to_plotly` crashing on touching bars (such as `plt.hist`) due to floating-point noise producing negative `bargap` values by clamping `bargap` to `[0, 1]` [[#5696](https://github.com/plotly/plotly.py/pull/5696)], with thanks to @robertoffmoura for the contribution!
 - Fix `mpl_to_plotly` drawing step plots with diagonal lines instead of vertical/horizontal step segments by mapping matplotlib step drawstyles (`steps-pre`, `steps-post`, `steps-mid`) to plotly line shapes [[#5697](https://github.com/plotly/plotly.py/pull/5697)], with thanks to @robertoffmoura for the contribution!
+- Export tick label colors to the plotly tickfont in `mpl_to_plotly` [[#5716](https://github.com/plotly/plotly.py/pull/5716)], with thanks to @robertoffmoura for the contribution!
 - Fix `px.sunburst`, `px.treemap` and `px.icicle` listing sectors in a different order on every run when `path` is used with a Polars DataFrame; sectors now follow their order of first appearance for all dataframe backends [[#5766](https://github.com/plotly/plotly.py/pull/5766)], with thanks to @Irahan2 for the contribution!
 
 ## [7.1.0] - 2026-09-15

plotly/matplotlylib/mplexporter/utils.py

@@ -200,18 +200,36 @@ def get_text_style(text):
 def get_axis_properties(axis):
     """Return the property dictionary for a matplotlib.Axis instance"""
     props = {}
-    label1On = axis.get_tick_params().get("label1On", True)
+    tick_params = axis.get_tick_params()
 
     if isinstance(axis, matplotlib.axis.XAxis):
-        if label1On:
-            props["position"] = "bottom"
-        else:
+        if (
+            axis.get_ticks_position() == "top"
+            or axis.get_label_position() == "top"
+            or (
+                tick_params.get("labeltop", False)
+                and not tick_params.get("labelbottom", False)
+            )
+            or (tick_params.get("top", False) and not tick_params.get("bottom", False))
+            or not tick_params.get("label1On", True)
+        ):
             props["position"] = "top"
-    elif isinstance(axis, matplotlib.axis.YAxis):
-        if label1On:
-            props["position"] = "left"
         else:
+            props["position"] = "bottom"
+    elif isinstance(axis, matplotlib.axis.YAxis):
+        if (
+            axis.get_ticks_position() == "right"
+            or axis.get_label_position() == "right"
+            or (
+                tick_params.get("labelright", False)
+                and not tick_params.get("labelleft", False)
+            )
+            or (tick_params.get("right", False) and not tick_params.get("left", False))
+            or not tick_params.get("label1On", True)
+        ):
             props["position"] = "right"
+        else:
+            props["position"] = "left"
     else:
         raise ValueError("{0} should be an Axis instance".format(axis))
 
@@ -239,12 +257,15 @@ def get_axis_properties(axis):
     # Get axis scale
     props["scale"] = axis.get_scale()
 
-    # Get major tick label size (assumes that's all we really care about!)
+    # Get major tick label size and color (assumes that's all we really
+    # care about!)
     labels = axis.get_ticklabels()
     if labels:
         props["fontsize"] = labels[0].get_fontsize()
+        props["fontcolor"] = export_color(labels[0].get_color())
     else:
         props["fontsize"] = None
+        props["fontcolor"] = None
 
     # Get associated grid
     props["grid"] = get_grid_style(axis)

plotly/matplotlylib/mpltools.py

@@ -250,15 +250,12 @@ def get_axes_bounds(fig):
     return (x_min, x_max), (y_min, y_max)
 
 
-def get_axis_mirror(main_spine, mirror_spine):
-    if main_spine and mirror_spine:
+def get_axis_mirror(main_spine, mirror_spine, main_tick_markers, mirror_tick_markers):
+    if main_spine and mirror_spine and main_tick_markers and mirror_tick_markers:
         return "ticks"
-    elif main_spine and not mirror_spine:
-        return False
-    elif not main_spine and mirror_spine:
-        return False  # can't handle this case yet!
-    else:
-        return False  # nuttin'!
+    if main_spine and mirror_spine:
+        return True
+    return False
 
 
 def get_bar_gap(bar_starts, bar_ends, tol=1e-10):
@@ -533,14 +530,32 @@ def prep_ticks(ax, index, ax_type, props):
     return axis_dict
 
 
+def _export_color(color):
+    """Export a matplotlib color for use as a plotly color.
+
+    matplotlib uses "none" for fully transparent colors, which plotly does not
+    accept, so transparent colors are exported as transparent black.
+    Colors already exported by the mplexporter (hex or rgba strings) are
+    passed through unchanged.
+    """
+    if color is None:
+        return None
+    if isinstance(color, str):
+        return color if color != "none" else "rgba(0,0,0,0)"
+    return [_export_color(c) for c in color]
+
+
 def prep_xy_axis(ax, props, x_bounds, y_bounds):
     xaxis = dict(
         type=props["axes"][0]["scale"],
         range=list(props["xlim"]),
         showgrid=props["axes"][0]["grid"]["gridOn"],
         domain=convert_x_domain(props["bounds"], x_bounds),
         side=props["axes"][0]["position"],
-        tickfont=dict(size=props["axes"][0]["fontsize"]),
+        tickfont=dict(
+            size=props["axes"][0]["fontsize"],
+            color=_export_color(props["axes"][0]["fontcolor"]),
+        ),
     )
     xaxis.update(prep_ticks(ax, 0, "x", props))
     yaxis = dict(
@@ -549,7 +564,10 @@ def prep_xy_axis(ax, props, x_bounds, y_bounds):
         showgrid=props["axes"][1]["grid"]["gridOn"],
         domain=convert_y_domain(props["bounds"], y_bounds),
         side=props["axes"][1]["position"],
-        tickfont=dict(size=props["axes"][1]["fontsize"]),
+        tickfont=dict(
+            size=props["axes"][1]["fontsize"],
+            color=_export_color(props["axes"][1]["fontcolor"]),
+        ),
     )
     yaxis.update(prep_ticks(ax, 1, "y", props))
     return xaxis, yaxis

plotly/matplotlylib/renderer.py

@@ -14,17 +14,7 @@
 from plotly.matplotlylib import mpltools
 
 
-def _export_color(color):
-    """Export a matplotlib color for use as a plotly color.
-
-    matplotlib uses "none" for fully transparent colors, which plotly does not
-    accept, so transparent colors are exported as transparent black.
-    Colors already exported by the mplexporter (hex or rgba strings) are
-    passed through unchanged.
-    """
-    if isinstance(color, str):
-        return "rgba(0,0,0,0)" if color == "none" else color
-    return [_export_color(c) for c in color]
+from plotly.matplotlylib.mpltools import _export_color
 
 
 class PlotlyRenderer(Renderer):
@@ -67,6 +57,7 @@ def __init__(self):
         self.msg = "Initialized PlotlyRenderer\n"
         self._processing_legend = False
         self._legend_visible = False
+        self.axes_list = []
 
     def _convert_x_dates(self, x):
         """Convert x values to date strings when the x-axis is a date axis."""
@@ -167,8 +158,8 @@ def open_axes(self, ax, props):
         ]
         self.current_bars = []
         self.axis_ct += 1
-        # update plot background with the axes background from mpl
-        self.plotly_fig["layout"].plot_bgcolor = _export_color(props["axesbg"])
+        if props.get("patch_visible", True):
+            self.plotly_fig["layout"].plot_bgcolor = _export_color(props["axesbg"])
         # set defaults in axes
         xaxis = go.layout.XAxis(
             anchor="y{0}".format(self.axis_ct), zeroline=False, ticks="inside"
@@ -186,10 +177,63 @@ def open_axes(self, ax, props):
         top_spine = mpltools.get_spine_visible(ax, "top")
         left_spine = mpltools.get_spine_visible(ax, "left")
         right_spine = mpltools.get_spine_visible(ax, "right")
-        xaxis["mirror"] = mpltools.get_axis_mirror(bottom_spine, top_spine)
-        yaxis["mirror"] = mpltools.get_axis_mirror(left_spine, right_spine)
-        xaxis["showline"] = bottom_spine
-        yaxis["showline"] = top_spine
+        x_tick_params = ax.xaxis.get_tick_params()
+        y_tick_params = ax.yaxis.get_tick_params()
+        bottom_tick_markers = x_tick_params.get(
+            "bottom", x_tick_params.get("left", True)
+        )
+        top_tick_markers = x_tick_params.get("top", x_tick_params.get("right", False))
+        left_tick_markers = y_tick_params.get("left", True)
+        right_tick_markers = y_tick_params.get("right", False)
+        if xaxis["side"] == "top":
+            x_main_spine, x_mirror_spine = top_spine, bottom_spine
+            x_main_ticks, x_mirror_ticks = top_tick_markers, bottom_tick_markers
+        else:
+            x_main_spine, x_mirror_spine = bottom_spine, top_spine
+            x_main_ticks, x_mirror_ticks = bottom_tick_markers, top_tick_markers
+
+        xaxis["mirror"] = mpltools.get_axis_mirror(
+            x_main_spine, x_mirror_spine, x_main_ticks, x_mirror_ticks
+        )
+        xaxis["showline"] = x_main_spine
+        # hide tick markers when the mpl main-side tick markers are hidden
+        if not x_main_ticks:
+            xaxis["ticks"] = ""
+
+        if yaxis["side"] == "right":
+            y_main_spine, y_mirror_spine = right_spine, left_spine
+            y_main_ticks, y_mirror_ticks = right_tick_markers, left_tick_markers
+        else:
+            y_main_spine, y_mirror_spine = left_spine, right_spine
+            y_main_ticks, y_mirror_ticks = left_tick_markers, right_tick_markers
+
+        yaxis["mirror"] = mpltools.get_axis_mirror(
+            y_main_spine, y_mirror_spine, y_main_ticks, y_mirror_ticks
+        )
+        yaxis["showline"] = y_main_spine
+        if not y_main_ticks:
+            yaxis["ticks"] = ""
+
+        overlay_ax_ct = None
+        for prev_ax, prev_ct in self.axes_list:
+            # Overlay only axes that cover the same area. Shared-axis subplots, such
+            # as the ones from plt.subplots(sharex=True), sit in different places.
+            if ax.get_position().bounds == prev_ax.get_position().bounds:
+                overlay_ax_ct = prev_ct
+                break
+
+        if overlay_ax_ct is not None:
+            overlay_x = "x" if overlay_ax_ct == 1 else "x{0}".format(overlay_ax_ct)
+            overlay_y = "y" if overlay_ax_ct == 1 else "y{0}".format(overlay_ax_ct)
+            xaxis["overlaying"] = overlay_x
+            yaxis["overlaying"] = overlay_y
+
+        if not props["axes"][0]["visible"]:
+            xaxis["visible"] = False
+        if not props["axes"][1]["visible"]:
+            yaxis["visible"] = False
+
+        self.axes_list.append((ax, self.axis_ct))
 
         # put axes in our figure
         self.plotly_fig["layout"]["xaxis{0}".format(self.axis_ct)] = xaxis