maidr 1.0.0__tar.gz → 1.2.0__tar.gz

{maidr-1.0.0 → maidr-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: maidr
-Version: 1.0.0
+Version: 1.2.0
 Summary: Multimodal Access and Interactive Data Representations
 License: GPL-3.0-or-later
 Keywords: accessibility,visualization,sonification,braille,tactile,multimodal,data representation,blind,low vision,visual impairments
@@ -29,8 +29,10 @@ Requires-Dist: htmltools (>=0.5)
 Requires-Dist: jupyter (>=1.0.0,<2.0.0)
 Requires-Dist: lxml (>=5.1.0)
 Requires-Dist: matplotlib (>=3.8)
+Requires-Dist: mplfinance (>=0.12.10b0,<0.13.0)
 Requires-Dist: numpy (>=1.26)
 Requires-Dist: seaborn (>=0.12)
+Requires-Dist: statsmodels (>=0.14.4,<0.15.0)
 Requires-Dist: virtualenv (>=20.26.6,<21.0.0)
 Requires-Dist: wrapt (>=1.16.0,<2.0.0)
 Project-URL: Homepage, https://xability.github.io/py-maidr

{maidr-1.0.0 → maidr-1.2.0}/maidr/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.0.0"
+__version__ = "1.2.0"
 
 from .api import close, render, save_html, show, stacked
 from .core import Maidr
@@ -6,12 +6,15 @@ from .core.enum import PlotType
 from .patch import (
     barplot,
     boxplot,
+    candlestick,
     clear,
     heatmap,
     highlight,
     histogram,
     lineplot,
     scatterplot,
+    regplot,
+    kdeplot,
 )
 
 __all__ = [

{maidr-1.0.0 → maidr-1.2.0}/maidr/api.py

@@ -40,9 +40,10 @@ def save_html(
     if isinstance(ax, list):
         for axes in ax:
             maidr = FigureManager.get_maidr(axes.get_figure())
-            htmls.append(maidr.render())
-        htmls[-1].save_html(file, libdir=lib_dir, include_version=include_version)
-        return htmls[-1]
+            htmls.append(maidr._create_html_doc(use_iframe=False))
+        return htmls[-1].save_html(
+            file, libdir=lib_dir, include_version=include_version
+        )
     else:
         maidr = FigureManager.get_maidr(ax.get_figure())
         return maidr.save_html(file, lib_dir=lib_dir, include_version=include_version)

{maidr-1.0.0 → maidr-1.2.0}/maidr/core/enum/plot_type.py

@@ -13,3 +13,5 @@ class PlotType(str, Enum):
     LINE = "line"
     SCATTER = "point"
     STACKED = "stacked_bar"
+    SMOOTH = "smooth"
+    CANDLESTICK = "candlestick"

maidr-1.2.0/maidr/core/enum/smooth_keywords.py

@@ -0,0 +1,10 @@
+# Keywords used to detect smooth/regression lines in MAIDR
+SMOOTH_KEYWORDS = [
+    "smooth",
+    "lowess",
+    "regression",
+    "linear regression",
+    "kde",
+    "density",
+    "gaussian",
+]

{maidr-1.0.0 → maidr-1.2.0}/maidr/core/figure_manager.py

@@ -48,18 +48,24 @@ class FigureManager:
         return cls._instance
 
     @classmethod
-    def create_maidr(cls, ax: Axes, plot_type: PlotType, **kwargs) -> Maidr:
+    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."""
-        if ax is None:
+        if axes is None:
             raise ValueError("No plot found.")
         if plot_type is None:
             raise ValueError("No plot type found.")
+        if isinstance(axes, list):
+            ax = axes[0]
+        else:
+            ax = axes
         if ax.get_figure() is None:
             raise ValueError(f"No figure found for axis: {ax}.")
 
         # Add plot to the Maidr object associated with the plot's figure.
         maidr = cls._get_maidr(ax.get_figure(), plot_type)
-        plot = MaidrPlotFactory.create(ax, plot_type, **kwargs)
+        plot = MaidrPlotFactory.create(axes, plot_type, **kwargs)
         maidr.plots.append(plot)
         maidr.selector_ids.append(Maidr._unique_id())
         return maidr

{maidr-1.0.0 → maidr-1.2.0}/maidr/core/maidr.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from datetime import datetime
+
 import io
 import json
 import os
@@ -12,12 +14,13 @@ import matplotlib.pyplot as plt
 from htmltools import HTML, HTMLDocument, Tag, tags
 from lxml import etree
 from matplotlib.figure import Figure
+from maidr.core.enum.plot_type import PlotType
 
 from maidr.core.context_manager import HighlightContextManager
 from maidr.core.enum.maidr_key import MaidrKey
-from maidr.core.enum.plot_type import PlotType
 from maidr.core.plot import MaidrPlot
 from maidr.util.environment import Environment
+from maidr.util.dedup_utils import deduplicate_smooth_and_line
 
 
 class Maidr:
@@ -62,7 +65,7 @@ class Maidr:
 
     def render(self) -> Tag:
         """Return the maidr plot inside an iframe."""
-        return self._create_html_tag()
+        return self._create_html_tag(use_iframe=True)
 
     def save_html(
         self, file: str, *, lib_dir: str | None = "lib", include_version: bool = True
@@ -80,7 +83,9 @@ class Maidr:
         include_version : bool, default=True
             Whether to include the version number in the dependency folder name.
         """
-        html = self._create_html_doc()
+        html = self._create_html_doc(
+            use_iframe=False
+        )  # Always use direct HTML for saving
         return html.save_html(file, libdir=lib_dir, include_version=include_version)
 
     def show(
@@ -96,7 +101,7 @@ class Maidr:
         renderer : Literal["auto", "ipython", "browser"], default="auto"
             The renderer to use for the HTML preview.
         """
-        html = self._create_html_tag()
+        html = self._create_html_tag(use_iframe=True)  # Always use iframe for display
         _renderer = Environment.get_renderer()
         if _renderer == "browser" or (
             Environment.is_interactive_shell() and not Environment.is_notebook()
@@ -122,10 +127,12 @@ class Maidr:
         os.makedirs(static_temp_dir, exist_ok=True)
 
         temp_file_path = os.path.join(static_temp_dir, "maidr_plot.html")
-        html_file_path = self.save_html(temp_file_path)
+        html_file_path = self.save_html(
+            temp_file_path
+        )  # This will use use_iframe=False
         webbrowser.open(f"file://{html_file_path}")
 
-    def _create_html_tag(self) -> Tag:
+    def _create_html_tag(self, use_iframe: bool = True) -> Tag:
         """Create the MAIDR HTML using HTML tags."""
         tagged_elements: list[Any] = [
             element for plot in self._plots for element in plot.elements
@@ -141,16 +148,32 @@ class Maidr:
         maidr = f"\nlet maidr = {json.dumps(self._flatten_maidr(), indent=2)}\n"
 
         # Inject plot's svg and MAIDR structure into html tag.
-        return Maidr._inject_plot(svg, maidr, self.maidr_id)
+        return Maidr._inject_plot(svg, maidr, self.maidr_id, use_iframe)
 
-    def _create_html_doc(self) -> HTMLDocument:
+    def _create_html_doc(self, use_iframe: bool = True) -> HTMLDocument:
         """Create an HTML document from Tag objects."""
-        return HTMLDocument(self._create_html_tag(), lang="en")
+        return HTMLDocument(self._create_html_tag(use_iframe), lang="en")
 
     def _flatten_maidr(self) -> dict | list[dict]:
         """Return a single plot schema or a list of schemas from the Maidr instance."""
         if self.plot_type in (PlotType.DODGED, PlotType.STACKED):
             self._plots = [self._plots[0]]
+        # Deduplicate: if any SMOOTH plots exist, remove LINE plots
+        self._plots = deduplicate_smooth_and_line(self._plots)
+
+        unique_gids = set()
+        deduped_plots = []
+        for plot in self._plots:
+            if getattr(plot, "type", None) == PlotType.SMOOTH:
+                gid = getattr(plot, "_smooth_gid", None)
+                if gid and gid in unique_gids:
+                    continue
+                if gid:
+                    unique_gids.add(gid)
+                deduped_plots.append(plot)
+            else:
+                deduped_plots.append(plot)
+        self._plots = deduped_plots
 
         plot_schemas = []
 
@@ -243,17 +266,19 @@ class Maidr:
         return str(uuid.uuid4())
 
     @staticmethod
-    def _inject_plot(plot: HTML, maidr: str, maidr_id) -> Tag:
+    def _inject_plot(plot: HTML, maidr: str, maidr_id, use_iframe: bool = True) -> Tag:
         """Embed the plot and associated MAIDR scripts into the HTML structure."""
-        # MAIDR_TS_CDN_URL = "http://localhost:8080/maidr.js"  # DEMO URL
-        MAIDR_TS_CDN_URL = "https://cdn.jsdelivr.net/npm/maidr@3.11.4/dist/maidr.js"
+        # MAIDR_TS_CDN_URL = "http://localhost:8888/tree/maidr/core/maidr.js"  # DEMO URL
+        MAIDR_TS_CDN_URL = "https://cdn.jsdelivr.net/npm/maidr@latest/dist/maidr.js"
+        # Append a query parameter (using TIMESTAMP) to bust the cache (so that the latest (non-cached) version is always loaded).
+        TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
 
         script = f"""
-            if (!document.querySelector('script[src="{MAIDR_TS_CDN_URL}"]'))
+            if (!document.querySelector('script[src="{MAIDR_TS_CDN_URL}?v={TIMESTAMP}"]'))
             {{
                 var script = document.createElement('script');
                 script.type = 'module';
-                script.src = '{MAIDR_TS_CDN_URL}';
+                script.src = '{MAIDR_TS_CDN_URL}?v={TIMESTAMP}';
                 script.addEventListener('load', function() {{
                     window.main();
                 }});
@@ -279,7 +304,7 @@ 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 Environment.is_notebook() or Environment.is_shiny():
+        if use_iframe and (Environment.is_notebook() or Environment.is_shiny()):
             unique_id = "iframe_" + Maidr._unique_id()
 
             def generate_iframe_script(unique_id: str) -> str:

{maidr-1.0.0 → maidr-1.2.0}/maidr/core/plot/boxplot.py

@@ -178,19 +178,39 @@ class BoxPlot(
             "boxes": [],
             "outliers": [],
         }
+        self.lower_outliers_count = []
 
     def _get_selector(self) -> list[dict]:
         mins, maxs, medians, boxes, outliers = self.elements_map.values()
         selector = []
-        for min, max, median, box, outlier in zip(mins, maxs, medians, boxes, outliers):
+
+        for (
+            min,
+            max,
+            median,
+            box,
+            outlier,
+            lower_outliers_count,
+        ) in zip(
+            mins,
+            maxs,
+            medians,
+            boxes,
+            outliers,
+            self.lower_outliers_count,
+        ):
             selector.append(
                 {
-                    MaidrKey.LOWER_OUTLIER.value: ["g[id=" + outlier + "] > g > use"],
-                    MaidrKey.MIN.value: "g[id=" + min + "] > path",
-                    MaidrKey.MAX.value: "g[id=" + max + "] > path",
-                    MaidrKey.Q2.value: "g[id=" + median + "] > path",
-                    MaidrKey.IQ.value: "g[id=" + box + "] > path",
-                    MaidrKey.UPPER_OUTLIER.value: ["g[id=" + outlier + "] > g > use"],
+                    MaidrKey.LOWER_OUTLIER.value: [
+                        f"g[id='{outlier}'] > g > :nth-child(-n+{lower_outliers_count} of use:not([visibility='hidden']))"
+                    ],
+                    MaidrKey.MIN.value: f"g[id='{min}'] > path",
+                    MaidrKey.MAX.value: f"g[id='{max}'] > path",
+                    MaidrKey.Q2.value: f"g[id='{median}'] > path",
+                    MaidrKey.IQ.value: f"g[id='{box}'] > path",
+                    MaidrKey.UPPER_OUTLIER.value: [
+                        f"g[id='{outlier}'] > g > :nth-child(n+{lower_outliers_count + 1} of use:not([visibility='hidden']))"
+                    ],
                 }
             )
         return selector if self._orientation == "vert" else list(reversed(selector))
@@ -217,6 +237,9 @@ class BoxPlot(
         medians = self._bxp_extractor.extract_medians(bxp_stats["medians"])
         outliers = self._bxp_extractor.extract_outliers(bxp_stats["fliers"], caps)
 
+        for outlier in outliers:
+            self.lower_outliers_count.append(len(outlier[MaidrKey.LOWER_OUTLIER.value]))
+
         caps_elements = self._bxp_elements_extractor.extract_caps(bxp_stats["caps"])
         bxp_maidr = []
 

maidr-1.2.0/maidr/core/plot/candlestick.py

@@ -0,0 +1,239 @@
+import matplotlib.dates as mdates
+import numpy as np
+from matplotlib.axes import Axes
+from matplotlib.collections import LineCollection, PatchCollection
+from matplotlib.patches import Rectangle
+
+from maidr.core.enum.plot_type import PlotType
+from maidr.core.plot.maidr_plot import MaidrPlot
+
+
+class CandlestickPlot(MaidrPlot):
+    def __init__(self, axes: list[Axes], **kwargs) -> None:
+        """
+        Initialize the CandlestickPlot.
+
+        Parameters
+        ----------
+        axes : list[Axes]
+            A list of Matplotlib Axes objects. Expected to contain at least
+            one Axes for OHLC data, and optionally a second for volume data.
+        **kwargs : dict
+            Additional keyword arguments.
+        """
+        self.axes = axes
+        # Ensure there's at least one axis for the superclass init
+        if not axes:
+            raise ValueError("Axes list cannot be empty.")
+        super().__init__(axes[0], PlotType.CANDLESTICK)
+
+    def _extract_plot_data(self) -> list[dict]:
+        """
+        Extracts candlestick (OHLC) and volume data from the plot axes.
+
+        This method assumes that the candlestick chart is structured with
+        LineCollection for wicks and PatchCollection of Rectangles for bodies
+        on the first axis (self.axes[0]). Volume data is expected as a
+        PatchCollection of Rectangles on the second axis (self.axes[1]), if present.
+        Open and close prices are inferred from the body rectangle's color.
+
+        Returns
+        -------
+        list[dict]
+            A list of dictionaries, where each dictionary represents a data point
+            with 'value' (date string YYYY-MM-DD), 'open', 'high', 'low',
+            'close', and 'volume'. Fields that cannot be extracted will be None.
+
+        Examples
+        --------
+        Assuming a plot has been generated and `plot_instance.axes` is populated:
+        >>> data = plot_instance._extract_plot_data()
+        >>> print(data[0])
+        {
+            'value': '2021-01-01',
+            'open': 100.0,
+            'high': 100.9,
+            'low': 99.27,
+            'close': 100.75,
+            'volume': 171914,
+        }
+        """
+        if not self.axes:
+            return []
+
+        plot_data: list[dict] = []
+        ax_ohlc: Axes = self.axes[0]
+
+        body_rectangles: list[Rectangle] = []
+        wick_collection: LineCollection | None = None
+
+        # Find candlestick body Rectangles from the OHLC axis
+        # Prefer PatchCollection containing Rectangles, fallback to individual Rectangles in ax.patches
+        for collection in ax_ohlc.collections:
+            if isinstance(collection, PatchCollection):
+                # Check if the collection's patches are Rectangles
+                try:
+                    # Iterating a PatchCollection yields its constituent Patch objects
+                    patches_are_rects = all(
+                        isinstance(p, Rectangle) for p in collection
+                    )
+                    if (
+                        patches_are_rects and len(collection.get_paths()) > 0
+                    ):  # Ensure it has paths and they are Rectangles
+                        for (
+                            patch
+                        ) in collection:  # Iterate to get actual Rectangle objects
+                            if isinstance(patch, Rectangle):
+                                body_rectangles.append(patch)
+                        if (
+                            body_rectangles
+                        ):  # If we found rectangles this way, assume this is the primary body collection
+                            break
+                except Exception:
+                    # Could fail if collection is not iterable in the expected way or patches are not Rectangles
+                    pass
+
+        if not body_rectangles:
+            for patch in ax_ohlc.patches:
+                if isinstance(patch, Rectangle):
+                    body_rectangles.append(patch)
+
+        if not body_rectangles:
+            pass
+
+        ax_for_wicks: Axes | None = None
+        if len(self.axes) > 1:
+            ax_for_wicks = self.axes[1]
+
+        if ax_for_wicks:
+            # Attempt 1: Find wicks in ax_for_wicks.collections (as a LineCollection)
+            for collection in ax_for_wicks.collections:
+                if isinstance(collection, LineCollection):
+                    segments = collection.get_segments()
+                    # Check if the collection contains segments and the first segment looks like a vertical line
+                    if segments is not None and len(segments) > 0:
+                        first_segment = segments[0]
+                        if (
+                            len(first_segment) == 2  # Segment consists of two points
+                            and len(first_segment[0]) == 2  # First point has (x, y)
+                            and len(first_segment[1]) == 2  # Second point has (x, y)
+                            and np.isclose(
+                                first_segment[0][0], first_segment[1][0]
+                            )  # X-coordinates are close (vertical)
+                        ):
+                            wick_collection = collection
+                            break  # Found a suitable LineCollection
+
+            # Attempt 2: If no LineCollection found, try to find wicks from individual Line2D objects in ax_for_wicks.get_lines()
+            if not wick_collection and hasattr(ax_for_wicks, "get_lines"):
+                potential_wick_segments = []
+                for line in ax_for_wicks.get_lines():  # Iterate over Line2D objects
+                    x_data, y_data = line.get_data()
+                    # A wick is typically a vertical line defined by two points.
+                    if len(x_data) == 2 and len(y_data) == 2:
+                        if np.isclose(x_data[0], x_data[1]):  # Check for verticality
+                            # Create a segment in the format [[x1, y1], [x2, y2]]
+                            segment = [
+                                [x_data[0], y_data[0]],
+                                [x_data[1], y_data[1]],
+                            ]
+                            potential_wick_segments.append(segment)
+
+                if potential_wick_segments:
+                    # If wick segments were found from individual lines,
+                    # create a new LineCollection to hold them.
+                    # This allows the downstream processing logic
+                    # for wicks to remain consistent.
+                    # Basic properties are set; color/linestyle
+                    # are defaults and may not match
+                    # the original plot's styling if that
+                    # were relevant for segment extraction.
+                    wick_collection = LineCollection(
+                        potential_wick_segments,
+                        colors="k",  # Default color for the temporary collection
+                        linestyles="solid",  # Default linestyle
+                    )
+
+        # Process wicks into a map: x_coordinate -> (low_price, high_price)
+        wick_segments_map: dict[float, tuple[float, float]] = {}
+        if wick_collection:
+            for seg in wick_collection.get_segments():
+                if len(seg) == 2 and len(seg[0]) == 2 and len(seg[1]) == 2:
+                    # Ensure x-coordinates are (nearly) identical for a vertical wick line
+                    if np.isclose(seg[0][0], seg[1][0]):
+                        x_coord = seg[0][0]  # Matplotlib date number
+                        low_price = min(seg[0][1], seg[1][1])
+                        high_price = max(seg[0][1], seg[1][1])
+                        wick_segments_map[x_coord] = (low_price, high_price)
+
+        body_rectangles.sort(key=lambda r: r.get_x())
+
+        for rect in body_rectangles:
+            x_left = rect.get_x()
+            width = rect.get_width()
+            x_center_num = x_left + width / 2.0
+
+            try:
+                date_dt = mdates.num2date(x_center_num)
+                date_str = date_dt.strftime("%Y-%m-%d")
+            except ValueError:
+                date_str = f"raw_date_{x_center_num:.2f}"
+
+            y_bottom = rect.get_y()
+            height = rect.get_height()
+            face_color = rect.get_facecolor()  # RGBA tuple
+
+            # Infer open and close prices
+            # Heuristic: Green component > Red component for an "up" candle (close > open)
+            # This assumes standard green for up, red for down.
+            # A more robust method would involve knowing the exact up/down colors used.
+            is_up_candle = (
+                face_color[1] > face_color[0]
+            )  # Compare Green and Red components
+
+            if is_up_candle:  # Typically green: price went up
+                open_price = y_bottom
+                close_price = y_bottom + height
+            else:  # Typically red: price went down (or other color)
+                close_price = y_bottom
+                open_price = y_bottom + height
+
+            matched_wick_data = None
+            closest_wick_x = None
+            min_diff = float("inf")
+
+            for wick_x, prices in wick_segments_map.items():
+                diff = abs(wick_x - x_center_num)
+                if diff < min_diff:
+                    min_diff = diff
+                    closest_wick_x = wick_x
+
+            # Tolerance for matching wick x-coordinate (e.g., 10% of candle width)
+            if closest_wick_x is not None and min_diff < (width * 0.1):
+                matched_wick_data = wick_segments_map[closest_wick_x]
+
+            if matched_wick_data:
+                low_price, high_price = matched_wick_data
+                # Ensure high >= max(open,close) and low <= min(open,close)
+                high_price = max(high_price, open_price, close_price)
+                low_price = min(low_price, open_price, close_price)
+            else:
+                # Fallback if no wick found: high is max(open,close), low is min(open,close)
+                high_price = max(open_price, close_price)
+                low_price = min(open_price, close_price)
+
+            plot_data.append(
+                {
+                    "value": date_str,
+                    "open": open_price,
+                    "high": high_price,
+                    "low": low_price,
+                    "close": close_price,
+                    "volume": 0,
+                }
+            )
+        self._elements.extend(body_rectangles)
+        return plot_data
+
+    def _extract_axes_data(self) -> dict:
+        return {}

{maidr-1.0.0 → maidr-1.2.0}/maidr/core/plot/maidr_plot_factory.py

@@ -5,12 +5,14 @@ from matplotlib.axes import Axes
 from maidr.core.enum import PlotType
 from maidr.core.plot.barplot import BarPlot
 from maidr.core.plot.boxplot import BoxPlot
+from maidr.core.plot.candlestick import CandlestickPlot
 from maidr.core.plot.grouped_barplot import GroupedBarPlot
 from maidr.core.plot.heatmap import HeatPlot
 from maidr.core.plot.histogram import HistPlot
 from maidr.core.plot.lineplot import MultiLinePlot
 from maidr.core.plot.maidr_plot import MaidrPlot
 from maidr.core.plot.scatterplot import ScatterPlot
+from maidr.core.plot.regplot import SmoothPlot
 
 
 class MaidrPlotFactory:
@@ -29,20 +31,37 @@ class MaidrPlotFactory:
     """
 
     @staticmethod
-    def create(ax: Axes, plot_type: PlotType, **kwargs) -> MaidrPlot:
-        if PlotType.BAR == plot_type or PlotType.COUNT == plot_type:
-            return BarPlot(ax)
+    def create(ax: Axes | list[Axes], plot_type: PlotType, **kwargs) -> MaidrPlot:
+        if isinstance(ax, list):
+            single_ax = ax[0]
+        else:
+            single_ax = ax
+
+        if plot_type == PlotType.CANDLESTICK:
+            if isinstance(ax, list):
+                # If ax is a list of lists, flatten it
+                if ax and isinstance(ax[0], list):
+                    axes = ax[0]  # Take the first inner list
+                else:
+                    axes = ax  # Use the list as-is
+            else:
+                axes = [ax]  # Wrap single axes in list
+            return CandlestickPlot(axes, **kwargs)
+        elif PlotType.BAR == plot_type or PlotType.COUNT == plot_type:
+            return BarPlot(single_ax)
         elif PlotType.BOX == plot_type:
-            return BoxPlot(ax, **kwargs)
+            return BoxPlot(single_ax, **kwargs)
         elif PlotType.HEAT == plot_type:
-            return HeatPlot(ax, **kwargs)
+            return HeatPlot(single_ax, **kwargs)
         elif PlotType.HIST == plot_type:
-            return HistPlot(ax)
+            return HistPlot(single_ax)
         elif PlotType.LINE == plot_type:
-            return MultiLinePlot(ax)
+            return MultiLinePlot(single_ax)
         elif PlotType.SCATTER == plot_type:
-            return ScatterPlot(ax)
+            return ScatterPlot(single_ax)
         elif PlotType.DODGED == plot_type or PlotType.STACKED == plot_type:
-            return GroupedBarPlot(ax, plot_type, **kwargs)
+            return GroupedBarPlot(single_ax, plot_type, **kwargs)
+        elif PlotType.SMOOTH == plot_type:
+            return SmoothPlot(single_ax, **kwargs)
         else:
             raise TypeError(f"Unsupported plot type: {plot_type}.")

maidr-1.2.0/maidr/core/plot/regplot.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from matplotlib.axes import Axes
+from maidr.core.plot.maidr_plot import MaidrPlot
+from maidr.exception.extraction_error import ExtractionError
+import numpy as np
+from maidr.core.enum.plot_type import PlotType
+from maidr.core.enum.maidr_key import MaidrKey
+from maidr.util.regression_line_utils import find_regression_line
+from maidr.util.svg_utils import data_to_svg_coords
+
+
+class SmoothPlot(MaidrPlot):
+    """
+    Extracts and represents a regression line as a smooth plot for MAIDR.
+
+    Parameters
+    ----------
+    ax : Axes
+        The matplotlib axes object containing the regression line.
+    """
+
+    def __init__(self, ax: Axes, **kwargs):
+        """
+        Initialize a SmoothPlot for a regression line.
+
+        Parameters
+        ----------
+        ax : Axes
+            The matplotlib axes object containing the regression line.
+        """
+        super().__init__(ax, PlotType.SMOOTH)
+        self._smooth_gid = None
+        self._regression_line = kwargs.get("regression_line", None)
+        self._poly_gid = kwargs.get("poly_gid", None)
+        self._is_polycollection = kwargs.get("is_polycollection", False)
+
+    def _get_selector(self):
+        """
+        Return the CSS selector for highlighting the regression line or PolyCollection in the SVG output.
+        """
+        if self._is_polycollection and self._poly_gid:
+            return [f"g[id='{self._poly_gid}'] > defs > path"]
+        if self._smooth_gid:
+            return [f"g[id='{self._smooth_gid}'] path"]
+        return ["g[id^='maidr-'] path"]
+
+    def _extract_plot_data(self) -> list:
+        """
+        Extract XY data from the regression line for serialization, including SVG coordinates.
+
+        Returns
+        -------
+        list
+            A list of lists containing dictionaries with X and Y coordinates, and SVG coordinates.
+        """
+        regression_line = (
+            self._regression_line
+            if self._regression_line is not None
+            else find_regression_line(self.ax)
+        )
+        if regression_line is None:
+            raise ExtractionError(PlotType.SMOOTH, self.ax)
+        self._elements.append(regression_line)
+        self._smooth_gid = regression_line.get_gid()
+        xydata = np.asarray(regression_line.get_xydata())
+        x_data, y_data = xydata[:, 0], xydata[:, 1]
+        x_svg, y_svg = data_to_svg_coords(self.ax, x_data, y_data)
+        return [
+            [
+                {
+                    MaidrKey.X: float(x),
+                    MaidrKey.Y: float(y),
+                    "svg_x": float(sx),
+                    "svg_y": float(sy),
+                }
+                for x, y, sx, sy in zip(x_data, y_data, x_svg, y_svg)
+            ]
+        ]

{maidr-1.0.0 → maidr-1.2.0}/maidr/patch/boxplot.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
 import wrapt
-
 from matplotlib.axes import Axes
 
-from maidr.core.context_manager import ContextManager, BoxplotContextManager
+from maidr.core.context_manager import BoxplotContextManager, ContextManager
 from maidr.core.enum import PlotType
 from maidr.core.figure_manager import FigureManager
 

maidr-1.2.0/maidr/patch/candlestick.py

@@ -0,0 +1,57 @@
+import wrapt
+from typing import Any, Callable, Dict, Tuple
+from matplotlib.patches import Rectangle
+from mplfinance import original_flavor
+
+from maidr.core.context_manager import ContextManager
+from maidr.core.enum.plot_type import PlotType
+from maidr.core.figure_manager import FigureManager
+
+
+def candlestick(
+    wrapped: Callable[..., list[Rectangle]],
+    instance: Any,
+    args: Tuple[Any, ...],
+    kwargs: Dict[str, Any],
+) -> list[Rectangle]:
+    """
+    Patch function for candlestick plots.
+
+    This function patches the candlestick plotting function to extract
+    candlestick data and create MAIDR plot instances for visualization.
+
+    Parameters
+    ----------
+    wrapped : Callable[..., list[Rectangle]]
+        The original candlestick function to be wrapped.
+    instance : Any
+        The instance of the class where the function is being patched.
+    args : Tuple[Any, ...]
+        Positional arguments passed to the original function.
+    kwargs : Dict[str, Any]
+        Keyword arguments passed to the original function.
+
+    Returns
+    -------
+    list[Rectangle]
+        The list of Rectangle objects returned by the original candlestick function.
+
+    Notes
+    -----
+    This wrapper function is used by the wrapt library to patch the mplfinance
+    candlestick function. It creates MAIDR plot instances for candlestick charts
+    while preserving the original functionality.
+    """
+    with ContextManager.set_internal_context():
+        # Patch the plotting function.
+        plot = wrapped(*args, **kwargs)
+
+    axes = []
+    for ax in plot:
+        axes.append(FigureManager.get_axes(ax))
+    FigureManager.create_maidr(axes, PlotType.CANDLESTICK)
+
+    return plot
+
+
+wrapt.wrap_function_wrapper(original_flavor, "_candlestick", candlestick)

{maidr-1.0.0 → maidr-1.2.0}/maidr/patch/common.py

@@ -22,6 +22,7 @@ def common(plot_type, wrapped, _, args, kwargs) -> Any:
 
     # Extract the data points for MAIDR from the plot.
     ax = FigureManager.get_axes(plot)
-    FigureManager.create_maidr(ax, plot_type)
+    kwargs.pop("ax", None)
+    FigureManager.create_maidr(ax, plot_type, **kwargs)
 
     return plot

{maidr-1.0.0 → maidr-1.2.0}/maidr/patch/histogram.py

@@ -6,6 +6,8 @@ import numpy as np
 from matplotlib.axes import Axes
 from matplotlib.container import BarContainer
 from matplotlib.patches import Polygon
+from matplotlib.lines import Line2D
+import uuid
 
 from maidr.core.context_manager import ContextManager
 from maidr.core.enum import PlotType
@@ -21,6 +23,9 @@ def mpl_hist(
     np.ndarray,
     BarContainer | Polygon | list[BarContainer | Polygon],
 ]:
+    """
+    Patch matplotlib Axes.hist to register HIST layer for MAIDR.
+    """
     # Don't proceed if the call is made internally by the patched function.
     if ContextManager.is_internal_context():
         return wrapped(*args, **kwargs)
@@ -40,4 +45,27 @@ def mpl_hist(
 
 @wrapt.patch_function_wrapper("seaborn", "histplot")
 def sns_hist(wrapped, instance, args, kwargs) -> Axes:
-    return common(PlotType.HIST, wrapped, instance, args, kwargs)
+    """
+    Patch seaborn.histplot to register HIST and (if kde=True) SMOOTH layers for MAIDR.
+    """
+    # Register the histogram as HIST as before
+    ax = common(PlotType.HIST, wrapped, instance, args, kwargs)
+    # Only register KDE overlay as SMOOTH if kde=True was set
+    kde_enabled = kwargs.get("kde", False)
+    if kde_enabled:
+        # Find the KDE line(s) and register as SMOOTH
+        axes = ax if isinstance(ax, Axes) else getattr(ax, "axes", None)
+        if axes is not None:
+            for line in axes.get_lines():
+                if isinstance(line, Line2D):
+                    if line.get_gid() is None:
+                        gid = f"maidr-{uuid.uuid4()}"
+                        line.set_gid(gid)
+                    common(
+                        PlotType.SMOOTH,
+                        lambda *a, **k: axes,
+                        instance,
+                        args,
+                        dict(kwargs, regression_line=line),
+                    )
+    return ax

maidr-1.2.0/maidr/patch/kdeplot.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import wrapt
+import uuid
+import numpy as np
+from matplotlib.axes import Axes
+from matplotlib.lines import Line2D
+from matplotlib.collections import PolyCollection
+from maidr.core.enum import PlotType
+from maidr.patch.common import common
+from maidr.core.context_manager import ContextManager
+from maidr.util.svg_utils import unique_lines_by_xy
+
+
+def kde(wrapped, instance, args, kwargs) -> Axes | Line2D | PolyCollection:
+    """
+    Patch for seaborn.kdeplot: register all unique lines and/or filled boundaries as SMOOTH.
+    """
+    with ContextManager.set_internal_context():
+        plot = wrapped(*args, **kwargs)
+    ax = plot if isinstance(plot, Axes) else getattr(plot, "axes", None)
+    if ax is not None:
+        # Register all unique Line2D objects
+        lines = [line for line in ax.get_lines() if isinstance(line, Line2D)]
+        for kde_line in unique_lines_by_xy(lines):
+            if kde_line.get_gid() is None:
+                gid = f"maidr-{uuid.uuid4()}"
+                kde_line.set_gid(gid)
+            common(
+                PlotType.SMOOTH,
+                lambda *a, **k: ax,
+                instance,
+                args,
+                dict(kwargs, regression_line=kde_line),
+            )
+        # Register all PolyCollection boundaries as SMOOTH
+        for poly in [c for c in ax.collections if isinstance(c, PolyCollection)]:
+            if poly.get_paths():
+                path = poly.get_paths()[0]
+                boundary = path.vertices
+                # Defensive: ensure boundary is a numpy array
+                boundary = np.asarray(boundary)
+                kde_line = Line2D(boundary[:, 0], boundary[:, 1])
+                gid = f"maidr-{uuid.uuid4()}"
+                kde_line.set_gid(gid)
+                poly.set_gid(gid)  # Assign gid to PolyCollection group
+                common(
+                    PlotType.SMOOTH,
+                    lambda *a, **k: ax,
+                    instance,
+                    args,
+                    dict(
+                        kwargs,
+                        regression_line=kde_line,
+                        poly_gid=gid,
+                        is_polycollection=True,
+                    ),
+                )
+    return plot
+
+
+# Patch seaborn kdeplot
+wrapt.wrap_function_wrapper("seaborn", "kdeplot", kde)

{maidr-1.0.0 → maidr-1.2.0}/maidr/patch/lineplot.py

@@ -6,6 +6,7 @@ from matplotlib.lines import Line2D
 
 from maidr.core.enum import PlotType
 from maidr.patch.common import common
+from maidr.core.enum.smooth_keywords import SMOOTH_KEYWORDS
 
 
 def line(wrapped, instance, args, kwargs) -> Axes | list[Line2D]:

maidr-1.2.0/maidr/patch/regplot.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import wrapt
+from matplotlib.axes import Axes
+from matplotlib.lines import Line2D
+from maidr.core.enum import PlotType
+from maidr.patch.common import common
+import numpy as np
+from maidr.core.context_manager import ContextManager
+import uuid
+from maidr.core.enum.smooth_keywords import SMOOTH_KEYWORDS
+from maidr.util.regression_line_utils import find_regression_line
+
+
+def regplot(wrapped, instance, args, kwargs) -> Axes:
+    """
+    Patch seaborn.regplot to register SCATTER and SMOOTH layers for MAIDR.
+    """
+    scatter = kwargs.get("scatter", True)
+    if scatter:
+        ax = common(PlotType.SCATTER, wrapped, instance, args, kwargs)
+    else:
+        # Prevent any MAIDR layer registration during plotting when scatter=False
+        with ContextManager.set_internal_context():
+            ax = wrapped(*args, **kwargs)
+    axes = ax if isinstance(ax, Axes) else ax.axes if hasattr(ax, "axes") else None
+    if axes is not None:
+        regression_line = find_regression_line(axes)
+        if regression_line is not None:
+            # ---
+            # Assign a unique gid to the regression line if not already set.
+            # This is necessary because the SVG output may contain many <g> and <path> tags,
+            # and only the regression line should be uniquely selectable for accessibility and highlighting.
+            # By setting a unique gid, we ensure the backend and frontend can generate a reliable selector
+            # (e.g., g[id='maidr-...'] path) that matches only the intended regression line.
+            # ---
+            if regression_line.get_gid() is None:
+                new_gid = f"maidr-{uuid.uuid4()}"
+                regression_line.set_gid(new_gid)
+            common(
+                PlotType.SMOOTH,
+                lambda *a, **k: ax,
+                instance,
+                args,
+                dict(kwargs, regression_line=regression_line),
+            )
+    return ax
+
+
+def patched_plot(wrapped, instance, args, kwargs):
+    """
+    Patch matplotlib Axes.plot to register SMOOTH layers for MAIDR if the label matches SMOOTH_KEYWORDS.
+    """
+    # Call the original plot function
+    lines = wrapped(*args, **kwargs)
+    # lines can be a list of Line2D objects
+    for line in lines:
+        if isinstance(line, Line2D):
+            label = line.get_label() or ""
+            label_str = str(label)
+            # Detect if this is a smooth/regression line by label
+            if any(key in label_str.lower() for key in SMOOTH_KEYWORDS):
+                # Assign a unique gid if not already set
+                if line.get_gid() is None:
+                    new_gid = f"maidr-{uuid.uuid4()}"
+                    line.set_gid(new_gid)
+                # Register as a smooth layer
+                common(
+                    PlotType.SMOOTH,
+                    lambda *a, **k: instance,
+                    instance,
+                    args,
+                    dict(kwargs, regression_line=line),
+                )
+    return lines
+
+
+# Patch seaborn function.
+wrapt.wrap_function_wrapper("seaborn", "regplot", regplot)
+# Patch matplotlib Axes.plot for smooth line detection/registration
+wrapt.wrap_function_wrapper(Axes, "plot", patched_plot)

maidr-1.2.0/maidr/util/dedup_utils.py

@@ -0,0 +1,12 @@
+from maidr.core.enum.plot_type import PlotType
+from typing import List
+
+
+def deduplicate_smooth_and_line(plots: List[object]) -> List[object]:
+    """
+    If any SMOOTH plots exist, remove all LINE plots from the list.
+    """
+    has_smooth = any(getattr(plot, "type", None) == PlotType.SMOOTH for plot in plots)
+    if has_smooth:
+        return [plot for plot in plots if getattr(plot, "type", None) != PlotType.LINE]
+    return plots

maidr-1.2.0/maidr/util/regression_line_utils.py

@@ -0,0 +1,19 @@
+from matplotlib.lines import Line2D
+import numpy as np
+
+
+def find_regression_line(axes):
+    """
+    Helper to find the regression line (Line2D) in the given axes.
+    """
+    return next(
+        (
+            artist
+            for artist in axes.get_children()
+            if isinstance(artist, Line2D)
+            and artist.get_label() not in (None, "", "_nolegend_")
+            and artist.get_xydata() is not None
+            and np.asarray(artist.get_xydata()).size > 0
+        ),
+        None,
+    )

maidr-1.2.0/maidr/util/svg_utils.py

@@ -0,0 +1,46 @@
+import numpy as np
+from matplotlib.axes import Axes
+from matplotlib.lines import Line2D
+from typing import List, Tuple
+
+
+def data_to_svg_coords(
+    ax: Axes, x_data: np.ndarray, y_data: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Convert data coordinates to SVG coordinates using matplotlib transforms.
+    Returns x_svg, y_svg arrays in SVG points.
+    """
+    fig = getattr(ax, "figure", None)
+    if fig is None:
+        import matplotlib.pyplot as plt
+
+        fig = plt.gcf()
+    try:
+        fig.tight_layout()
+    except Exception:
+        pass
+    xy_disp = ax.transData.transform(np.column_stack([x_data, y_data]))
+    xy_figpix = fig.transFigure.inverted().transform(xy_disp)
+    fig_width_pts = fig.get_size_inches()[0] * 72
+    fig_height_pts = fig.get_size_inches()[1] * 72
+    x_svg = xy_figpix[:, 0] * fig_width_pts
+    y_svg = (1 - xy_figpix[:, 1]) * fig_height_pts
+    return x_svg, y_svg
+
+
+def unique_lines_by_xy(lines: List[Line2D]) -> List[Line2D]:
+    """
+    Deduplicate lines by rounded xy data (8 decimals). Only lines with >0 points are kept.
+    """
+    seen_xy = set()
+    unique_lines = []
+    for line in lines:
+        xy = np.asarray(line.get_xydata())
+        if xy.shape[0] == 0:
+            continue
+        xy_rounded = tuple(map(tuple, np.round(xy, 8)))
+        if xy_rounded not in seen_xy:
+            seen_xy.add(xy_rounded)
+            unique_lines.append(line)
+    return unique_lines

{maidr-1.0.0 → maidr-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "maidr"
-version = "1.0.0"
+version = "1.2.0"
 description = "Multimodal Access and Interactive Data Representations"
 authors = [
     "JooYoung Seo <jseo1005@illinois.edu>",
@@ -43,6 +43,8 @@ htmltools = ">=0.5"
 jupyter = "^1.0.0"
 wrapt = "^1.16.0"
 virtualenv = "^20.26.6"
+mplfinance = "^0.12.10b0"
+statsmodels = "^0.14.4"
 
 [tool.poetry.group.dev.dependencies]
 black = "23.3.0"
@@ -71,7 +73,7 @@ match = "(main|master)"
 prerelease_token = "rc"
 prerelease = false
 
-[tool.semantic_release.changelog]
+[tool.semantic_release.changelog.default_templates]
 template_dir = "templates"
 changelog_file = "CHANGELOG.md"
 exclude_commit_patterns = [