maidr 1.7.1__tar.gz → 1.7.3__tar.gz

{maidr-1.7.1 → maidr-1.7.3}/CHANGELOG.md

@@ -1,6 +1,29 @@
 # CHANGELOG
 
 
+## v1.7.3 (2025-09-15)
+
+### Bug Fixes
+
+- Ensure all subplots are accessible and improve dodged plot detection
+  ([#242](https://github.com/xability/py-maidr/pull/242),
+  [`979b971`](https://github.com/xability/py-maidr/commit/979b9713d07be8bc9046056e7f1c0519336ddd22))
+
+Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
+
+Co-authored-by: jooyoungseo <19754711+jooyoungseo@users.noreply.github.com>
+
+Co-authored-by: JooYoung Seo <jseo1005@illinois.edu>
+
+
+## v1.7.2 (2025-09-12)
+
+### Bug Fixes
+
+- Prevent iframe resizing when modal is open ([#237](https://github.com/xability/py-maidr/pull/237),
+  [`89a4253`](https://github.com/xability/py-maidr/commit/89a42537a32025b286b8089b7f4b21b7c409c4e4))
+
+
 ## v1.7.1 (2025-09-03)
 
 ### Bug Fixes

{maidr-1.7.1 → maidr-1.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maidr
-Version: 1.7.1
+Version: 1.7.3
 Summary: Multimodal Access and Interactive Data Representations
 Project-URL: Homepage, https://xability.github.io/py-maidr
 Project-URL: Repository, https://github.com/xability/py-maidr

{maidr-1.7.1 → maidr-1.7.3}/example/flask/test_flask_app.py

@@ -1,5 +1,6 @@
 import matplotlib
-matplotlib.use('Agg')  # Use non-interactive backend for Flask
+
+matplotlib.use("Agg")  # Use non-interactive backend for Flask
 
 from flask import Flask
 import matplotlib.pyplot as plt
@@ -14,7 +15,8 @@ logger = logging.getLogger(__name__)
 
 app = Flask(__name__)
 
-@app.route('/')
+
+@app.route("/")
 def index():
     # Log environment detection
     logger.info("=== Environment Detection ===")
@@ -34,8 +36,12 @@ def index():
     logger.info(f"flask_detected: {flask_detected}")
     logger.info(f"notebook_detected: {notebook_detected}")
     logger.info(f"shiny_detected: {shiny_detected}")
-    logger.info("Condition: use_iframe and (flask_detected or notebook_detected or shiny_detected)")
-    logger.info(f"Result: {use_iframe and (flask_detected or notebook_detected or shiny_detected)}")
+    logger.info(
+        "Condition: use_iframe and (flask_detected or notebook_detected or shiny_detected)"
+    )
+    logger.info(
+        f"Result: {use_iframe and (flask_detected or notebook_detected or shiny_detected)}"
+    )
 
     # Load the penguins dataset
     penguins = sns.load_dataset("penguins")
@@ -65,7 +71,8 @@ def index():
     # Return the maidr HTML directly
     return str(maidr_html)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     logger.info("Starting Flask app with logging...")
     logger.info("Visit http://localhost:5002 to see the maidr plot in Flask")
-    app.run(debug=False, host='0.0.0.0', port=5002)
+    app.run(debug=False, host="0.0.0.0", port=5002)

{maidr-1.7.1 → maidr-1.7.3}/maidr/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.7.1"
+__version__ = "1.7.3"
 
 from .api import close, render, save_html, show, stacked
 from .core import Maidr

{maidr-1.7.1 → maidr-1.7.3}/maidr/core/figure_manager.py

@@ -15,20 +15,24 @@ from maidr.core.plot import MaidrPlotFactory
 
 class FigureManager:
     """
-    Manages creation and retrieval of Maidr instances associated with matplotlib figures.
+    Manages creation and retrieval of Maidr instances associated with figures.
 
-    This class provides methods to manage Maidr objects which facilitate the organization and
-    manipulation of plots within matplotlib figures.
+    This class provides methods to manage Maidr objects which facilitate the
+    organization and manipulation of plots within matplotlib figures.
 
     Attributes
     ----------
     figs : dict
-        A dictionary that maps matplotlib Figure objects to their corresponding Maidr instances.
+        A dictionary that maps matplotlib Figure objects to their corresponding
+        Maidr instances.
+    PLOT_TYPE_PRIORITY : dict
+        Defines the priority order for plot types. Higher numbers take precedence.
 
     Methods
     -------
     create_maidr(ax, plot_type, **kwargs)
-        Creates a Maidr instance for the given Axes and plot type, and adds a plot to it.
+        Creates a Maidr instance for the given Axes and plot type, and adds a
+        plot to it.
     _get_maidr(fig)
         Retrieves or creates a Maidr instance associated with the given Figure.
     get_axes(artist)
@@ -37,6 +41,21 @@ class FigureManager:
 
     figs = {}
 
+    # Define plot type priority order (higher numbers take precedence)
+    PLOT_TYPE_PRIORITY = {
+        PlotType.BAR: 1,
+        PlotType.STACKED: 2,
+        PlotType.DODGED: 2,  # DODGED and STACKED have same priority
+        PlotType.LINE: 1,
+        PlotType.SCATTER: 1,
+        PlotType.HIST: 1,
+        PlotType.BOX: 1,
+        PlotType.HEAT: 1,
+        PlotType.COUNT: 1,
+        PlotType.SMOOTH: 1,
+        PlotType.CANDLESTICK: 1,
+    }
+
     _instance = None
     _lock = threading.Lock()
 
@@ -44,14 +63,15 @@ class FigureManager:
         if not cls._instance:
             with cls._lock:
                 if not cls._instance:
-                    cls._instance = super(FigureManager, cls).__new__()
+                    cls._instance = super(FigureManager, cls).__new__(cls)
         return cls._instance
 
     @classmethod
     def create_maidr(
         cls, axes: Axes | list[Axes], plot_type: PlotType, **kwargs
     ) -> Maidr:
-        """Create a Maidr instance for the given Axes and plot type, and adds a plot to it."""
+        """Create a Maidr instance for the given Axes and plot type, and
+        adds a plot to it."""
         if axes is None:
             raise ValueError("No plot found.")
         if plot_type is None:
@@ -72,9 +92,34 @@ class FigureManager:
 
     @classmethod
     def _get_maidr(cls, fig: Figure, plot_type: PlotType) -> Maidr:
-        """Retrieve or create a Maidr instance for the given Figure."""
+        """
+        Retrieve or create a Maidr instance for the given Figure.
+
+        If a Maidr instance already exists for the figure, update its plot type
+        if the new plot type has higher priority (DODGED/STACKED > BAR).
+
+        Parameters
+        ----------
+        fig : Figure
+            The matplotlib figure to get or create a Maidr instance for.
+        plot_type : PlotType
+            The plot type to set or update for the Maidr instance.
+
+        Returns
+        -------
+        Maidr
+            The Maidr instance associated with the figure.
+        """
         if fig not in cls.figs.keys():
             cls.figs[fig] = Maidr(fig, plot_type)
+        else:
+            # Update plot type if the new type has higher priority
+            maidr = cls.figs[fig]
+            current_priority = cls.PLOT_TYPE_PRIORITY.get(maidr.plot_type, 0)
+            new_priority = cls.PLOT_TYPE_PRIORITY.get(plot_type, 0)
+
+            if new_priority > current_priority:
+                maidr.plot_type = plot_type
         return cls.figs[fig]
 
     @classmethod

{maidr-1.7.1 → maidr-1.7.3}/maidr/core/maidr.py

@@ -10,6 +10,7 @@ import webbrowser
 import subprocess
 from pathlib import Path
 from typing import Any, Literal, cast
+from collections import defaultdict
 
 import matplotlib.pyplot as plt
 from htmltools import HTML, HTMLDocument, Tag, tags
@@ -159,10 +160,7 @@ class Maidr:
             if explorer_path:
                 try:
                     result = subprocess.run(
-                        [explorer_path, url],
-                        capture_output=True,
-                        text=True,
-                        timeout=10
+                        [explorer_path, url], capture_output=True, text=True, timeout=10
                     )
 
                     if result.returncode == 0:
@@ -204,10 +202,49 @@ class Maidr:
         """Create an HTML document from Tag objects."""
         return HTMLDocument(self._create_html_tag(use_iframe), lang="en")
 
+    def _merge_plots_by_subplot_position(self) -> list[MaidrPlot]:
+        """
+        Merge plots by their subplot position, keeping only the first plot per position.
+
+        For DODGED and STACKED plot types, multiple plots on the same subplot
+        should be merged into a single plot since GroupedBarPlot extracts all
+        containers from the axes itself.
+
+        Returns
+        -------
+        list[MaidrPlot]
+            List of plots with one plot per unique subplot position.
+
+        Examples
+        --------
+        If we have plots at positions [(0,0), (0,0), (0,1), (1,0)],
+        this will return plots at positions [(0,0), (0,1), (1,0)].
+        """
+        # Group plots by their subplot position (row, col) using defaultdict
+        subplot_groups: dict[tuple[int, int], list[MaidrPlot]] = defaultdict(list)
+
+        for plot in self._plots:
+            # Get subplot position, defaulting to (0, 0) if not set
+            position = (getattr(plot, "row_index", 0), getattr(plot, "col_index", 0))
+            subplot_groups[position].append(plot)
+
+        # Keep only the first plot for each subplot position
+        # The GroupedBarPlot will extract all containers from that axes
+        merged_plots: list[MaidrPlot] = []
+        for position_plots in subplot_groups.values():
+            merged_plots.append(
+                position_plots[0]
+            )  # Each list is guaranteed to have at least one plot
+
+        return merged_plots
+
     def _flatten_maidr(self) -> dict | list[dict]:
         """Return a single plot schema or a list of schemas from the Maidr instance."""
+        # Handle DODGED/STACKED plots: only keep one plot per subplot position
+        # because GroupedBarPlot extracts all containers from the axes itself
         if self.plot_type in (PlotType.DODGED, PlotType.STACKED):
-            self._plots = [self._plots[0]]
+            self._plots = self._merge_plots_by_subplot_position()
+
         # Deduplicate: if any SMOOTH plots exist, remove LINE plots
         self._plots = deduplicate_smooth_and_line(self._plots)
 
@@ -354,7 +391,11 @@ class Maidr:
         # Render the plot inside an iframe if in a Jupyter notebook, Google Colab
         # or VSCode notebook. No need for iframe if this is a Quarto document.
         # For TypeScript we will use iframe by default for now
-        if use_iframe and (Environment.is_flask() or Environment.is_notebook() or Environment.is_shiny()):
+        if use_iframe and (
+            Environment.is_flask()
+            or Environment.is_notebook()
+            or Environment.is_shiny()
+        ):
             unique_id = "iframe_" + Maidr._unique_id()
 
             def generate_iframe_script(unique_id: str) -> str:
@@ -366,16 +407,29 @@ class Maidr:
                             iframe.contentWindow.document
                         ) {{
                             let iframeDocument = iframe.contentWindow.document;
-                            let brailleContainer =
-                                iframeDocument.getElementById('braille-input');
+                            // Detect braille textarea by dynamic id prefix
+                            let brailleContainer = iframeDocument.querySelector('[id^="maidr-braille-textarea"]');
+                            // Detect review input container by class name
+                            let reviewInputContainer = iframeDocument.querySelector('.maidr-review-input');
                             iframe.style.height = 'auto';
                             let height = iframeDocument.body.scrollHeight;
-                            if (brailleContainer &&
-                                brailleContainer === iframeDocument.activeElement
-                            ) {{
+                            // Consider braille active if it or any descendant has focus
+                            let isBrailleActive = brailleContainer && (
+                                brailleContainer === iframeDocument.activeElement ||
+                                (typeof brailleContainer.contains === 'function' && brailleContainer.contains(iframeDocument.activeElement))
+                            );
+                            // Consider review input active if it or any descendant has focus
+                            let isReviewInputActive = reviewInputContainer && (
+                                reviewInputContainer === iframeDocument.activeElement ||
+                                (typeof reviewInputContainer.contains === 'function' && reviewInputContainer.contains(iframeDocument.activeElement))
+                            );
+                            // (logs removed)
+                            if (isBrailleActive) {{
                                 height += 100;
-                            }}else{{
-                                height += 50
+                            }} else if (isReviewInputActive) {{
+                                height += 50;
+                            }} else {{
+                                height += 50;
                             }}
                             iframe.style.height = (height) + 'px';
                             iframe.style.width = iframeDocument.body.scrollWidth + 'px';
@@ -387,12 +441,32 @@ class Maidr:
                         resizeIframe();
                         iframe.contentWindow.addEventListener('resize', resizeIframe);
                     }};
-                    iframe.contentWindow.document.addEventListener('focusin', () => {{
-                        resizeIframe();
-                    }});
-                    iframe.contentWindow.document.addEventListener('focusout', () => {{
-                        resizeIframe();
-                    }});
+                    // Delegate focus events for braille textarea (by id prefix)
+                    iframe.contentWindow.document.addEventListener('focusin', (e) => {{
+                        try {{
+                            const t = e && e.target ? e.target : null;
+                            if (t && typeof t.id === 'string' && t.id.startsWith('maidr-braille-textarea')) resizeIframe();
+                        }} catch (_) {{ resizeIframe(); }}
+                    }}, true);
+                    iframe.contentWindow.document.addEventListener('focusout', (e) => {{
+                        try {{
+                            const t = e && e.target ? e.target : null;
+                            if (t && typeof t.id === 'string' && t.id.startsWith('maidr-braille-textarea')) resizeIframe();
+                        }} catch (_) {{ resizeIframe(); }}
+                    }}, true);
+                    // Delegate focus events for review input container (by class name)
+                    iframe.contentWindow.document.addEventListener('focusin', (e) => {{
+                        try {{
+                            const t = e && e.target ? e.target : null;
+                            if (t && t.classList && t.classList.contains('maidr-review-input')) resizeIframe();
+                        }} catch (_) {{ resizeIframe(); }}
+                    }}, true);
+                    iframe.contentWindow.document.addEventListener('focusout', (e) => {{
+                        try {{
+                            const t = e && e.target ? e.target : null;
+                            if (t && t.classList && t.classList.contains('maidr-review-input')) resizeIframe();
+                        }} catch (_) {{ resizeIframe(); }}
+                    }}, true);
                 """
                 return resizing_script
 

{maidr-1.7.1 → maidr-1.7.3}/maidr/core/plot/candlestick.py

@@ -43,7 +43,9 @@ class CandlestickPlot(MaidrPlot):
         self._maidr_wick_collection = kwargs.get("_maidr_wick_collection", None)
         self._maidr_body_collection = kwargs.get("_maidr_body_collection", None)
         self._maidr_date_nums = kwargs.get("_maidr_date_nums", None)
-        self._maidr_original_data = kwargs.get("_maidr_original_data", None)  # Store original data
+        self._maidr_original_data = kwargs.get(
+            "_maidr_original_data", None
+        )  # Store original data
         self._maidr_datetime_converter = kwargs.get("_maidr_datetime_converter", None)
 
         # Store the GID for proper selector generation (legacy/shared)
@@ -122,7 +124,9 @@ class CandlestickPlot(MaidrPlot):
                     for rect in body_rectangles:
                         rect.set_gid(self._maidr_gid)
                 # Keep a dedicated body gid for legacy dict selectors
-                self._maidr_body_gid = getattr(self, "_maidr_body_gid", None) or self._maidr_gid
+                self._maidr_body_gid = (
+                    getattr(self, "_maidr_body_gid", None) or self._maidr_gid
+                )
 
                 # Assign a shared gid to wick Line2D (vertical 2-point lines) on the same axis
                 wick_lines = []
@@ -132,7 +136,11 @@ class CandlestickPlot(MaidrPlot):
                         if xydata is None:
                             continue
                         xy_arr = np.asarray(xydata)
-                        if xy_arr.ndim == 2 and xy_arr.shape[0] == 2 and xy_arr.shape[1] >= 2:
+                        if (
+                            xy_arr.ndim == 2
+                            and xy_arr.shape[0] == 2
+                            and xy_arr.shape[1] >= 2
+                        ):
                             x0 = float(xy_arr[0, 0])
                             x1 = float(xy_arr[1, 0])
                             if abs(x0 - x1) < 1e-10:
@@ -176,7 +184,12 @@ class CandlestickPlot(MaidrPlot):
         - Legacy path: return a dict with body and shared wick selectors (no open/close keys)
         """
         # Modern path: build structured selectors using separate gids
-        if self._maidr_body_collection and self._maidr_wick_collection and self._maidr_body_gid and self._maidr_wick_gid:
+        if (
+            self._maidr_body_collection
+            and self._maidr_wick_collection
+            and self._maidr_body_gid
+            and self._maidr_wick_gid
+        ):
             # Determine candle count N
             N = None
             if self._maidr_original_data is not None:

{maidr-1.7.1 → maidr-1.7.3}/maidr/core/plot/lineplot.py

@@ -115,7 +115,9 @@ class MultiLinePlot(MaidrPlot, LineExtractorMixin):
                 line_type = label
 
             # Use the new method to extract data with categorical labels
-            line_coords = LineExtractorMixin.extract_line_data_with_categorical_labels(self.ax, line)
+            line_coords = LineExtractorMixin.extract_line_data_with_categorical_labels(
+                self.ax, line
+            )
             if line_coords is None:
                 continue
 

{maidr-1.7.1 → maidr-1.7.3}/maidr/core/plot/maidr_plot.py

@@ -5,6 +5,7 @@ from abc import ABC, abstractmethod
 from matplotlib.axes import Axes
 
 from maidr.core.enum import MaidrKey, PlotType
+
 # uuid is used to generate unique identifiers for each plot layer in the MAIDR schema.
 import uuid
 

{maidr-1.7.1 → maidr-1.7.3}/maidr/core/plot/mplfinance_lineplot.py

@@ -105,7 +105,10 @@ class MplfinanceLinePlot(MaidrPlot, LineExtractorMixin):
                     continue
 
                 # Use datetime converter for enhanced data extraction
-                datetime_converter = getattr(line, "_maidr_datetime_converter", None) or self._maidr_datetime_converter
+                datetime_converter = (
+                    getattr(line, "_maidr_datetime_converter", None)
+                    or self._maidr_datetime_converter
+                )
                 if datetime_converter is not None:
                     # Convert x-coordinate (matplotlib index) to formatted datetime
                     x_value = datetime_converter.get_formatted_datetime(int(round(x)))

maidr-1.7.3/maidr/patch/barplot.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Tuple, Union
+
+import wrapt
+from matplotlib.axes import Axes
+from matplotlib.container import BarContainer
+
+from maidr.core.enum import PlotType
+from maidr.patch.common import common
+
+
+def bar(
+    wrapped: Callable, instance: Any, args: Tuple[Any, ...], kwargs: Dict[str, Any]
+) -> Union[Axes, BarContainer]:
+    """
+    Patch function for bar plots.
+
+    This function patches the bar plotting functions to identify whether the
+    plot should be rendered as a normal, stacked, or dodged bar plot.
+    It uses the 'bottom' keyword to identify stacked bar plots. For dodged plots,
+    it first checks for seaborn-specific indicators (hue parameter with dodge=True),
+    then uses robust detection logic that considers both width and context
+    to avoid misclassifying simple bar plots with narrow widths as dodged plots.
+
+    Parameters
+    ----------
+    wrapped : Callable
+        The original function to be wrapped.
+    instance : Any
+        The instance of the class where the function is being patched.
+    args : tuple
+        Positional arguments passed to the original function.
+        For a dodged plot, the first argument (x positions) should be numeric.
+    kwargs : dict
+        Keyword arguments passed to the original function.
+        For seaborn plots, may contain 'hue' and 'dodge' parameters.
+
+    Returns
+    -------
+    Union[Axes, BarContainer]
+        The axes or bar container returned by the original function.
+
+    Examples
+    --------
+    >>> # For a seaborn dodged (grouped) bar plot:
+    >>> sns.barplot(data=df, x='category', y='value', hue='group', dodge=True)
+
+    >>> # For a manual dodged (grouped) bar plot, pass numeric x positions:
+    >>> x_positions = np.arange(3)
+    >>> ax.bar(x_positions, heights, width, label='Group')  # Dodged bar plot.
+    """
+    plot_type = PlotType.BAR
+
+    # Check for stacked plots first (explicit bottom parameter)
+    if "bottom" in kwargs:
+        bottom = kwargs.get("bottom")
+        if bottom is not None:
+            plot_type = PlotType.STACKED
+    else:
+        # Check for seaborn-specific dodged plot indicators first
+        # This handles seaborn.barplot with hue and dodge=True
+        if "hue" in kwargs and kwargs.get("dodge"):
+            plot_type = PlotType.DODGED
+        else:
+            # Extract width and align parameters
+            if len(args) >= 3:
+                real_width = args[2]
+            else:
+                real_width = kwargs.get("width", 0.8)
+
+            align = kwargs.get("align", "center")
+
+            # More robust dodged plot detection: consider multiple factors
+            # Only classify as DODGED if there are strong indicators of grouping
+            should_be_dodged = _should_classify_as_dodged(
+                instance, real_width, align, args, kwargs
+            )
+
+            if should_be_dodged:
+                plot_type = PlotType.DODGED
+
+    return common(plot_type, wrapped, instance, args, kwargs)
+
+
+def _should_classify_as_dodged(
+    ax: Any, width: Any, align: str, args: Tuple[Any, ...], kwargs: Dict[str, Any]
+) -> bool:
+    """
+    Determine if a bar plot should be classified as dodged based on context.
+
+    This function uses more sophisticated logic than just checking width < 0.8,
+    as simple bar plots with narrow widths should not be considered dodged.
+
+    Parameters
+    ----------
+    ax : Any
+        The axes instance where the plot is being created.
+    width : Any
+        The width parameter for the bar plot.
+    align : str
+        The alignment parameter for the bar plot.
+    args : tuple
+        Positional arguments passed to the bar function.
+    kwargs : dict
+        Keyword arguments passed to the bar function.
+
+    Returns
+    -------
+    bool
+        True if the plot should be classified as DODGED, False otherwise.
+
+    Examples
+    --------
+    >>> # These should be DODGED:
+    >>> ax.bar([0.1, 1.1, 2.1], [1, 2, 3], width=0.4, label='Group A')
+    >>> ax.bar([0.4, 1.4, 2.4], [4, 5, 6], width=0.4, label='Group B')
+
+    >>> # These should remain BAR:
+    >>> ax.bar(['A', 'B', 'C'], [1, 2, 3], width=0.6)  # Simple categorical bar plot
+    """
+    # If align is 'edge', it's likely a dodged plot
+    if align == "edge":
+        return True
+
+    # If width is specified and very narrow (< 0.5), more likely to be dodged
+    # But only if there are other indicators
+    if isinstance(width, (int, float)) and float(width) < 0.5:
+        # Check if x positions suggest grouping (numeric positions with fractional parts)
+        if len(args) > 0:
+            x_positions = args[0]
+            if _has_numeric_grouping_pattern(x_positions):
+                return True
+
+    # Check if there are already multiple bar containers on the axes
+    # This suggests that this might be part of a grouped bar plot
+    if hasattr(ax, "containers") and len(ax.containers) > 0:
+        # If there are existing containers, this might be adding to a group
+        if isinstance(width, (int, float)) and float(width) < 0.8:
+            return True
+
+    # Check for explicit grouping indicators in kwargs
+    if "label" in kwargs and isinstance(width, (int, float)) and float(width) < 0.8:
+        # If there's a label and narrow width, it might be part of a group
+        # But we need to be conservative here to avoid false positives
+        if _has_numeric_grouping_pattern(args[0] if len(args) > 0 else None):
+            return True
+
+    # Default to False - prefer BAR over DODGED for ambiguous cases
+    return False
+
+
+def _has_numeric_grouping_pattern(x_positions: Any) -> bool:
+    """
+    Check if x positions suggest a grouping pattern typical of dodged plots.
+
+    Parameters
+    ----------
+    x_positions : Any
+        The x positions for the bar plot.
+
+    Returns
+    -------
+    bool
+        True if the positions suggest grouping, False otherwise.
+
+    Examples
+    --------
+    >>> _has_numeric_grouping_pattern([0.1, 1.1, 2.1])  # True - fractional offsets
+    >>> _has_numeric_grouping_pattern(['A', 'B', 'C'])  # False - categorical
+    >>> _has_numeric_grouping_pattern([0, 1, 2])        # False - simple numeric
+    """
+    try:
+        # Convert to list if possible (duck typing)
+        try:
+            positions = list(x_positions)
+        except TypeError:
+            return False
+
+        # If all positions are strings, it's categorical (not dodged)
+        if all(isinstance(pos, str) for pos in positions):
+            return False
+
+        # If positions are numeric, check for fractional offsets
+        # that suggest manual positioning for grouping
+        numeric_positions = []
+        for pos in positions:
+            try:
+                numeric_positions.append(float(pos))
+            except (ValueError, TypeError):
+                return False
+
+        if len(numeric_positions) < 2:
+            return False
+
+        # Check if positions have fractional parts that suggest manual offset
+        # for grouping (e.g., [0.1, 1.1, 2.1] or [0.8, 1.8, 2.8])
+        fractional_parts = [pos % 1 for pos in numeric_positions]
+
+        # If all have the same non-zero fractional part, it suggests grouping
+        if all(abs(frac - fractional_parts[0]) < 0.01 for frac in fractional_parts):
+            if fractional_parts[0] > 0.01:  # Non-zero fractional part
+                return True
+
+        return False
+
+    except Exception:
+        # If anything goes wrong in analysis, default to False
+        return False
+
+
+# Patch matplotlib functions.
+wrapt.wrap_function_wrapper(Axes, "bar", bar)
+wrapt.wrap_function_wrapper(Axes, "barh", bar)
+
+# Patch seaborn functions.
+wrapt.wrap_function_wrapper("seaborn", "barplot", bar)
+wrapt.wrap_function_wrapper("seaborn", "countplot", bar)

{maidr-1.7.1 → maidr-1.7.3}/maidr/patch/mplfinance.py

@@ -72,6 +72,7 @@ def mplfinance_plot_patch(wrapped, instance, args, kwargs):
             # fallback: use index if it's a DatetimeIndex
             try:
                 import matplotlib.dates as mdates
+
                 date_nums = [mdates.date2num(d) for d in data.index]
             except Exception:
                 pass
@@ -82,7 +83,7 @@ def mplfinance_plot_patch(wrapped, instance, args, kwargs):
                 datetime_converter = create_datetime_converter(data)
 
                 # Use enhanced converter's date_nums for mplfinance compatibility
-                if date_nums is None and hasattr(datetime_converter, 'date_nums'):
+                if date_nums is None and hasattr(datetime_converter, "date_nums"):
                     date_nums = datetime_converter.date_nums
 
     # Process and register the Candlestick plot