maidr 1.7.2__py3-none-any.whl → 1.8.0__py3-none-any.whl

maidr/__init__.py

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

maidr/api.py

@@ -11,7 +11,44 @@ from maidr.core.enum import PlotType
 from maidr.core.figure_manager import FigureManager
 
 
-def render(plot: Any) -> Tag:
+def _get_plot_or_current(plot: Any | None) -> Any:
+    """
+    Get the plot object or current matplotlib figure if plot is None.
+    
+    Parameters
+    ----------
+    plot : Any or None
+        The plot object. If None, returns the current matplotlib figure.
+        
+    Returns
+    -------
+    Any
+        The plot object or current matplotlib figure.
+    """
+    if plot is None:
+        # Lazy import matplotlib.pyplot when needed
+        import matplotlib.pyplot as plt
+        
+        return plt.gcf()
+    return plot
+
+
+def render(plot: Any | None = None) -> Tag:
+    """
+    Render a MAIDR plot to HTML.
+
+    Parameters
+    ----------
+    plot : Any or None, optional
+        The plot object to render. If None, uses the current matplotlib figure.
+
+    Returns
+    -------
+    htmltools.Tag
+        The rendered HTML representation of the plot.
+    """
+    plot = _get_plot_or_current(plot)
+    
     ax = FigureManager.get_axes(plot)
     if isinstance(ax, list):
         for axes in ax:
@@ -23,10 +60,29 @@ def render(plot: Any) -> Tag:
 
 
 def show(
-    plot: Any,
+    plot: Any | None = None,
     renderer: Literal["auto", "ipython", "browser"] = "auto",
     clear_fig: bool = True,
 ) -> object:
+    """
+    Display a MAIDR plot.
+
+    Parameters
+    ----------
+    plot : Any or None, optional
+        The plot object to display. If None, uses the current matplotlib figure.
+    renderer : {"auto", "ipython", "browser"}, default "auto"
+        The renderer to use for display.
+    clear_fig : bool, default True
+        Whether to clear the figure after displaying.
+
+    Returns
+    -------
+    object
+        The display result.
+    """
+    plot = _get_plot_or_current(plot)
+    
     ax = FigureManager.get_axes(plot)
     if isinstance(ax, list):
         for axes in ax:
@@ -38,8 +94,33 @@ def show(
 
 
 def save_html(
-    plot: Any, file: str, *, lib_dir: str | None = "lib", include_version: bool = True
+    plot: Any | None = None,
+    *, 
+    file: str,
+    lib_dir: str | None = "lib", 
+    include_version: bool = True
 ) -> str:
+    """
+    Save a MAIDR plot as HTML file.
+
+    Parameters
+    ----------
+    plot : Any or None, optional
+        The plot object to save. If None, uses the current matplotlib figure.
+    file : str
+        The file path where to save the HTML.
+    lib_dir : str or None, default "lib"
+        Directory name for libraries.
+    include_version : bool, default True
+        Whether to include version information.
+
+    Returns
+    -------
+    str
+        The path to the saved HTML file.
+    """
+    plot = _get_plot_or_current(plot)
+    
     ax = FigureManager.get_axes(plot)
     htmls = []
     if isinstance(ax, list):
@@ -59,6 +140,16 @@ def stacked(plot: Axes | BarContainer) -> Maidr:
     return FigureManager.create_maidr(ax, PlotType.STACKED)
 
 
-def close(plot: Any) -> None:
+def close(plot: Any | None = None) -> None:
+    """
+    Close a MAIDR plot and clean up resources.
+
+    Parameters
+    ----------
+    plot : Any or None, optional
+        The plot object to close. If None, uses the current matplotlib figure.
+    """
+    plot = _get_plot_or_current(plot)
+    
     ax = FigureManager.get_axes(plot)
     FigureManager.destroy(ax.get_figure())

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/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:

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/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/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/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/patch/barplot.py

@@ -18,9 +18,10 @@ def bar(
 
     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. If 'bottom'
-    is not provided and the x positions (first positional argument) are numeric,
-    then a dodged plot is assumed.
+    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
     ----------
@@ -33,6 +34,7 @@ def bar(
         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
     -------
@@ -41,33 +43,172 @@ def bar(
 
     Examples
     --------
-    >>> # For a dodged (grouped) bar plot, pass numeric x positions:
+    >>> # 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:
-        if len(args) >= 3:
-            real_width = args[2]
+        # 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:
-            real_width = kwargs.get("width", 0.8)
+            # 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")
+            align = kwargs.get("align", "center")
 
-        if (isinstance(real_width, (int, float)) and float(real_width) < 0.8) or (
-            align == "edge"
-        ):
-            plot_type = PlotType.DODGED
-    if "dodge" in kwargs:
-        plot_type = PlotType.DODGED
+            # 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)

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

maidr/util/datetime_conversion.py

@@ -3,6 +3,7 @@ import numpy as np
 from typing import Optional, Dict, Any, List, Tuple
 from datetime import datetime
 
+
 class DatetimeConverter:
     """
     Enhanced datetime converter that automatically detects time periods
@@ -58,7 +59,9 @@ class DatetimeConverter:
     >>> print(formatted_hourly)  # Output: "Jan 15 2024 09:00"
     """
 
-    def __init__(self, data: pd.DataFrame, datetime_format: Optional[str] = None) -> None:
+    def __init__(
+        self, data: pd.DataFrame, datetime_format: Optional[str] = None
+    ) -> None:
         """
         Initialize the DatetimeConverter.
 
@@ -120,7 +123,7 @@ class DatetimeConverter:
         # Calculate average time difference between consecutive data points
         time_diffs = []
         for i in range(1, len(self.data)):
-            diff = self.data.index[i] - self.data.index[i-1]
+            diff = self.data.index[i] - self.data.index[i - 1]
             time_diffs.append(diff.total_seconds())
 
         avg_diff_seconds = np.mean(time_diffs)
@@ -155,7 +158,7 @@ class DatetimeConverter:
             "day": "Daily data",
             "week": "Weekly data",
             "month": "Monthly data",
-            "unknown": "Unknown time period"
+            "unknown": "Unknown time period",
         }
         return period_descriptions.get(self.time_period, "Unknown time period")
 
@@ -236,6 +239,7 @@ class DatetimeConverter:
         """
         try:
             import matplotlib.dates as mdates
+
             date_nums = []
             for d in self.data.index:
                 try:
@@ -247,7 +251,9 @@ class DatetimeConverter:
         except Exception:
             return []
 
-    def extract_candlestick_data(self, ax, wick_collection=None, body_collection=None) -> List[Dict[str, Any]]:
+    def extract_candlestick_data(
+        self, ax, wick_collection=None, body_collection=None
+    ) -> List[Dict[str, Any]]:
         """
         Extract candlestick data with proper datetime formatting using original DataFrame.
 
@@ -273,33 +279,40 @@ class DatetimeConverter:
         datetime values using the enhanced datetime conversion logic.
         """
         candles = []
-        if not hasattr(self.data, 'Open') or not hasattr(self.data, 'High') or not hasattr(self.data, 'Low') or not hasattr(self.data, 'Close'):
+        if (
+            not hasattr(self.data, "Open")
+            or not hasattr(self.data, "High")
+            or not hasattr(self.data, "Low")
+            or not hasattr(self.data, "Close")
+        ):
             return candles
 
         for i in range(len(self.data)):
             try:
-                open_price = self.data.iloc[i]['Open']
-                high_price = self.data.iloc[i]['High']
-                low_price = self.data.iloc[i]['Low']
-                close_price = self.data.iloc[i]['Close']
-                volume = self.data.iloc[i].get('Volume', 0.0)
+                open_price = self.data.iloc[i]["Open"]
+                high_price = self.data.iloc[i]["High"]
+                low_price = self.data.iloc[i]["Low"]
+                close_price = self.data.iloc[i]["Close"]
+                volume = self.data.iloc[i].get("Volume", 0.0)
 
                 formatted_datetime = self.get_formatted_datetime(i)
 
                 candle_data = {
-                    'value': formatted_datetime or f"datetime_{i:03d}",
-                    'open': float(open_price),
-                    'high': float(high_price),
-                    'low': float(low_price),
-                    'close': float(close_price),
-                    'volume': float(volume)
+                    "value": formatted_datetime or f"datetime_{i:03d}",
+                    "open": float(open_price),
+                    "high": float(high_price),
+                    "low": float(low_price),
+                    "close": float(close_price),
+                    "volume": float(volume),
                 }
                 candles.append(candle_data)
             except (KeyError, IndexError, ValueError):
                 continue
         return candles
 
-    def extract_moving_average_data(self, ax, line_index: int = 0) -> List[Tuple[str, float]]:
+    def extract_moving_average_data(
+        self, ax, line_index: int = 0
+    ) -> List[Tuple[str, float]]:
         """
         Extract moving average data with proper datetime formatting and NaN filtering.
 
@@ -364,10 +377,10 @@ class DatetimeConverter:
         datetime values using the enhanced datetime conversion logic.
         """
         volume_data = []
-        if hasattr(self.data, 'Volume'):
+        if hasattr(self.data, "Volume"):
             for i in range(len(self.data)):
                 try:
-                    volume = self.data.iloc[i]['Volume']
+                    volume = self.data.iloc[i]["Volume"]
                     if pd.isna(volume) or volume <= 0:
                         continue
                     formatted_datetime = self.get_formatted_datetime(i)
@@ -377,7 +390,9 @@ class DatetimeConverter:
         return volume_data
 
 
-def create_datetime_converter(data: pd.DataFrame, datetime_format: Optional[str] = None) -> DatetimeConverter:
+def create_datetime_converter(
+    data: pd.DataFrame, datetime_format: Optional[str] = None
+) -> DatetimeConverter:
     """
     Factory function to create a DatetimeConverter instance.
 

maidr/util/environment.py

@@ -101,6 +101,7 @@ class Environment:
                 return False
         except ImportError:
             return False
+
     @staticmethod
     def is_wsl() -> bool:
         """
@@ -122,9 +123,9 @@ class Environment:
         False  # When not in WSL
         """
         try:
-            with open('/proc/version', 'r') as f:
+            with open("/proc/version", "r") as f:
                 version_info = f.read().lower()
-                if 'microsoft' in version_info or 'wsl' in version_info:
+                if "microsoft" in version_info or "wsl" in version_info:
                     return True
         except FileNotFoundError:
             pass
@@ -151,7 +152,7 @@ class Environment:
         >>> Environment.get_wsl_distro_name()
         ''  # When not in WSL or WSL_DISTRO_NAME not set
         """
-        return os.environ.get('WSL_DISTRO_NAME', '')
+        return os.environ.get("WSL_DISTRO_NAME", "")
 
     @staticmethod
     def find_explorer_path() -> Union[str, None]:
@@ -175,10 +176,7 @@ class Environment:
         # Check if explorer.exe is in PATH
         try:
             result = subprocess.run(
-                ['which', 'explorer.exe'],
-                capture_output=True,
-                text=True,
-                timeout=5
+                ["which", "explorer.exe"], capture_output=True, text=True, timeout=5
             )
             if result.returncode == 0:
                 return result.stdout.strip()
@@ -187,8 +185,6 @@ class Environment:
 
         return None
 
-
-
     @staticmethod
     def get_renderer() -> str:
         """Return renderer which can be ipython or browser."""

maidr/util/mixin/extractor_mixin.py

@@ -114,7 +114,9 @@ class LineExtractorMixin:
         return ax.get_lines()
 
     @staticmethod
-    def extract_line_data_with_categorical_labels(ax: Axes, line: Line2D) -> Optional[List[Tuple[Union[str, float], float]]]:
+    def extract_line_data_with_categorical_labels(
+        ax: Axes, line: Line2D
+    ) -> Optional[List[Tuple[Union[str, float], float]]]:
         """
         Extract line data with proper handling of categorical x-axis labels.
 

maidr/util/mplfinance_utils.py

@@ -231,7 +231,7 @@ class MplfinanceDataExtractor:
     def _determine_bull_bear_from_data(
         original_data: Optional[Union[pd.DataFrame, pd.Series, dict]],
         index: int,
-        date_str: str
+        date_str: str,
     ) -> bool:
         """
         Determine if a candle is bullish (up) or bearish (down) using original OHLC data.
@@ -258,19 +258,19 @@ class MplfinanceDataExtractor:
 
         try:
             # Try to access the original data
-            if hasattr(original_data, 'iloc'):
+            if hasattr(original_data, "iloc"):
                 # It's a pandas DataFrame/Series
                 if index < len(original_data):
                     row = original_data.iloc[index]
-                    if 'Close' in row and 'Open' in row:
-                        is_bullish = row['Close'] > row['Open']
+                    if "Close" in row and "Open" in row:
+                        is_bullish = row["Close"] > row["Open"]
                         return is_bullish
 
-            elif hasattr(original_data, '__getitem__'):
+            elif hasattr(original_data, "__getitem__"):
                 # It's a dictionary or similar
-                if 'Close' in original_data and 'Open' in original_data:
-                    closes = original_data['Close']
-                    opens = original_data['Open']
+                if "Close" in original_data and "Open" in original_data:
+                    closes = original_data["Close"]
+                    opens = original_data["Open"]
                     if index < len(closes) and index < len(opens):
                         is_bullish = closes[index] > opens[index]
                         return is_bullish

{maidr-1.7.2.dist-info → maidr-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maidr
-Version: 1.7.2
+Version: 1.8.0
 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.2.dist-info → maidr-1.8.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-maidr/__init__.py,sha256=X3vZu1thIgth4Y8f6nQ4R_DeyWdCRvj_ukKAZ_7bPT0,415
-maidr/api.py,sha256=gRNLXqUWpFGdD-I7Nu6J0_LeEni9KRAr0TBHwHaDAsc,1928
+maidr/__init__.py,sha256=WHwg8BcJQIcf4dsUFOdKS_frxDfuHewDEGnBBg9j3WE,415
+maidr/api.py,sha256=od539V0CKcs15FEXQo0hX_hK_A0U3noHE54obdHcTqY,4138
 maidr/core/__init__.py,sha256=WgxLpSEYMc4k3OyEOf1shOxfEq0ASzppEIZYmE91ThQ,25
 maidr/core/context_manager.py,sha256=6cT7ZGOApSpC-SLD2XZWWU_H08i-nfv-JUlzXOtvWYw,3374
-maidr/core/figure_manager.py,sha256=jXs-Prkeru1Pahj21hjh8BAwXM9ZFUZ3GFfKUfIRX_M,4117
-maidr/core/maidr.py,sha256=cXSE3Cymd6XQVk77KmQhWRtuvAX3nPzV2ZxpolsPr7w,18408
+maidr/core/figure_manager.py,sha256=t-lhe4jj2gsF5-8VUBUZOPlDutKjm_AZ8xXWJU2pFRc,5555
+maidr/core/maidr.py,sha256=0MuyPgc1CFomA87jq70GG-MSxYaMI2Z7ct2FAOGCxQM,20067
 maidr/core/enum/__init__.py,sha256=9ee78L0dlxEx4ulUGVlD-J23UcUZmrGu0rXms54up3c,93
 maidr/core/enum/library.py,sha256=e8ujT_L-McJWfoVJd1ty9K_2bwITnf1j0GPLsnAcHes,104
 maidr/core/enum/maidr_key.py,sha256=ljG0omqzd8K8Yk213N7i7PXGvG-IOlnE5v7o6RoGJzc,795
@@ -12,21 +12,21 @@ maidr/core/enum/smooth_keywords.py,sha256=z2kVZZ-mETWWh5reWu_hj9WkJD6WFj7_2-6s1e
 maidr/core/plot/__init__.py,sha256=xDIpRGM-4DfaSSL3nKcXrjdMecCHJ6en4K4nA_fPefQ,83
 maidr/core/plot/barplot.py,sha256=0hBgp__putezvxXc9G3qmaktmAzze3cN8pQMD9iqktE,2116
 maidr/core/plot/boxplot.py,sha256=i11GdNuz_c-hilmhydu3ah-bzyVdFoBkNvRi5lpMrrY,9946
-maidr/core/plot/candlestick.py,sha256=9R1ddSnUkGEE9WJgUPeuZhRtxXNBnOM9rbJdfJcY8bo,9886
+maidr/core/plot/candlestick.py,sha256=ofvlUwtzaaopvv6VjNDf1IZODbu1UkMHsi1zdvcG-Yo,10120
 maidr/core/plot/grouped_barplot.py,sha256=_zn4XMeEnSiDHtf6t4-z9ErBqg_CijhAS2CCtlHgYIQ,2077
 maidr/core/plot/heatmap.py,sha256=yMS-31tS2GW4peds9LtZesMxmmTV_YfqYO5M_t5KasQ,2521
 maidr/core/plot/histogram.py,sha256=QV5W-6ZJQQcZsrM91JJBX-ONktJzH7yg_et5_bBPfQQ,1525
-maidr/core/plot/lineplot.py,sha256=VbMjG-D5X-oeehduAtbqsyZ-hbcFc4NQYBwpCzgk4lo,4492
-maidr/core/plot/maidr_plot.py,sha256=9T0boWaonM99jggEed97-rCy_cufRMWXrXo-CbmPudE,4230
+maidr/core/plot/lineplot.py,sha256=uoJpGkJB3IJSDJTwH6ECxLyXGdarsVQNULELp5NncWg,4522
+maidr/core/plot/maidr_plot.py,sha256=heotWue1IzMOXnpoHVCqKSW88Sfep1IuuP4MBarpSek,4231
 maidr/core/plot/maidr_plot_factory.py,sha256=NW2iFScswgXbAC9rAOo4iMkAFsjY43DAvFioGr0yzx4,2732
 maidr/core/plot/mplfinance_barplot.py,sha256=zhTp2i6BH0xn7vQvGTotKgu2HbzlKT4p6zA5CVUUHHc,5673
-maidr/core/plot/mplfinance_lineplot.py,sha256=oRXFAa13wsz5i9tDN267ZSqd1-gGpOEzntmFTAz8o1w,7269
+maidr/core/plot/mplfinance_lineplot.py,sha256=pIbsusnQg1_GrstVVHfMw-t9yipWJowa9ZvGsiVV6l8,7329
 maidr/core/plot/regplot.py,sha256=b7u6bGTz1IxKahplNUrfwIr_OGSwMJ2BuLgFAVjL0s0,2744
 maidr/core/plot/scatterplot.py,sha256=o0i0uS-wXK9ZrENxneoHbh3-u-2goRONp19Yu9QLsaY,1257
 maidr/exception/__init__.py,sha256=PzaXoYBhyZxMDcJkuxJugDx7jZeseI0El6LpxIwXyG4,46
 maidr/exception/extraction_error.py,sha256=rd37Oxa9gn2OWFWt9AOH5fv0hNd3sAWGvpDMFBuJY2I,607
 maidr/patch/__init__.py,sha256=FnkoUQJC2ODhLO37GwgRVSitBCRax42Ti0e4NIAgdO0,236
-maidr/patch/barplot.py,sha256=qdUy5Y8zkMg4dH3fFh93OYzLdar4nl1u5O2Jcw4d2zI,2433
+maidr/patch/barplot.py,sha256=QncV4Wv0B5bfY3OekA_ga8tgRLNmRDJf89mnx7xeQzs,7762
 maidr/patch/boxplot.py,sha256=l7wDD4pDi4ZbsL5EX5XDhPRxgtSIFSrFguMOZ7IC2eg,2845
 maidr/patch/candlestick.py,sha256=R2MgPX5ih9W-RBluvF6jFNJBxETH0eMt7Tzn0Ej9LoU,2652
 maidr/patch/clear.py,sha256=2Sc4CIt5jRGkew3TxFsBZm-uowC9yDSxtraEcXZjmGw,396
@@ -36,23 +36,23 @@ maidr/patch/highlight.py,sha256=I1dGFHJAnVd0AHVnMJzk_TE8BC8Uv-I6fTzSrJLU5QM,1155
 maidr/patch/histogram.py,sha256=k3N0RUf1SQ2402pwbaY5QyS98KnLWvr9glCHQw9NTko,2378
 maidr/patch/kdeplot.py,sha256=qv-OKzuop2aTrkZgUe2OnLxvV-KMyeXt1Td0_uZeHzE,2338
 maidr/patch/lineplot.py,sha256=kvTAiOddy1g5GMP456Awk21NUEZfn-vWaYXy5GTVtuA,1841
-maidr/patch/mplfinance.py,sha256=L_C_EsIghUVVdtOxooa1a9Lxe-UcUpKuYV2Tw_bMDBw,9490
+maidr/patch/mplfinance.py,sha256=ySD32onanoMgdQkV6XlSAbVd_BQuLWuEQtpkYSEDSzA,9491
 maidr/patch/regplot.py,sha256=k86ekd0E4XJ_L1u85zObuDnxuXlM83z7tKtyXRTj2rI,3240
 maidr/patch/scatterplot.py,sha256=kln6zZwjVsdQzICalo-RnBOJrx1BnIB2xYUwItHvSNY,525
 maidr/util/__init__.py,sha256=eRJZfRpDX-n7UoV3JXw_9Lbfu_qNl_D0W1UTvLL-Iv4,81
-maidr/util/datetime_conversion.py,sha256=fl2MnSCmz8IqYIHsiQPWKkNz3lDrFyWoStkQPIDReCA,14364
+maidr/util/datetime_conversion.py,sha256=AQ8qShbEkLVo13TUkOOmtOLnOvaI05Vh5oWhgchvXSA,14478
 maidr/util/dedup_utils.py,sha256=RpgPL5p-3oULUHaTCZJaQKhPHfyPkvBLHMt8lAGpJ5A,438
-maidr/util/environment.py,sha256=SSfxzjmY2ZVA98B-IVql8n9AX3d6h2f7_R4t3_53dYI,9452
-maidr/util/mplfinance_utils.py,sha256=aWNRkNS2IAF4YYEF9w7CcmcKWMGg3KkYJAv0xL8KcyY,14417
+maidr/util/environment.py,sha256=C4VMyB16mqzrFxpJdxFdm40M0IZojxh60UX80680jgo,9403
+maidr/util/mplfinance_utils.py,sha256=OZe5Y7gzjdjve9DViioQvGZYTdZvz8obvN3oHElQFZw,14418
 maidr/util/plot_detection.py,sha256=bgLHoDcHSRwOiyKzUK3EqGwdAIhF44ocHW5ox6xYGZw,3883
 maidr/util/regression_line_utils.py,sha256=yFKr-H0whT_su2YVZwNksBLp5EC5s77sr6HUFgNcsyY,2329
 maidr/util/svg_utils.py,sha256=2gyzBtNKFHs0utrw1iOlxTmznzivOWQMV2aW8zu2c8E,1442
 maidr/util/mixin/__init__.py,sha256=aGJZNhtWh77yIVPc7ipIZm1OajigjMtCWYKPuDWTC-c,217
-maidr/util/mixin/extractor_mixin.py,sha256=l1DQTqZiVeZ18qXrz-rKCh8ETFofucBfwjIjO4S85HU,6923
+maidr/util/mixin/extractor_mixin.py,sha256=j2Rv2vh_gqqcxLV1ka3xsPaPAfWsX94CtKIW2FgPLnI,6937
 maidr/util/mixin/merger_mixin.py,sha256=V0qLw_6DUB7X6CQ3BCMpsCQX_ZuwAhoSTm_E4xAJFKM,712
 maidr/widget/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maidr/widget/shiny.py,sha256=wrrw2KAIpE_A6CNQGBtNHauR1DjenA_n47qlFXX9_rk,745
-maidr-1.7.2.dist-info/METADATA,sha256=8oaTlEpNVa5w8tBjKYofiFVj1h6Tn1fOAy54SyNZyz0,3154
-maidr-1.7.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-maidr-1.7.2.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-maidr-1.7.2.dist-info/RECORD,,
+maidr-1.8.0.dist-info/METADATA,sha256=JSCtmOqsD8Mka8aDihHcqHs4wJ9Yc4eBYV3by-pQSl0,3154
+maidr-1.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+maidr-1.8.0.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+maidr-1.8.0.dist-info/RECORD,,