maidr 0.25.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

maidr/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.25.2"
+__version__ = "1.1.0"
 
 from .api import close, render, save_html, show, stacked
 from .core import Maidr
@@ -12,6 +12,8 @@ from .patch import (
     histogram,
     lineplot,
     scatterplot,
+    regplot,
+    kdeplot,
 )
 
 __all__ = [

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/core/enum/plot_type.py

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

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/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/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/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/core/plot/maidr_plot_factory.py

@@ -11,6 +11,7 @@ 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:
@@ -44,5 +45,7 @@ class MaidrPlotFactory:
             return ScatterPlot(ax)
         elif PlotType.DODGED == plot_type or PlotType.STACKED == plot_type:
             return GroupedBarPlot(ax, plot_type, **kwargs)
+        elif PlotType.SMOOTH == plot_type:
+            return SmoothPlot(ax, **kwargs)
         else:
             raise TypeError(f"Unsupported plot type: {plot_type}.")

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/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/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/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/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/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/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/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/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-0.25.2.dist-info → maidr-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: maidr
-Version: 0.25.2
+Version: 1.1.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
@@ -31,6 +31,7 @@ Requires-Dist: lxml (>=5.1.0)
 Requires-Dist: matplotlib (>=3.8)
 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-0.25.2.dist-info → maidr-1.1.0.dist-info}/RECORD

@@ -1,22 +1,24 @@
-maidr/__init__.py,sha256=AvQGlxhltTWsgrRx-_v6qwFWoBVslLQpYUwy_yFBjcE,357
-maidr/api.py,sha256=2PkvPDhpPFEHmM99-jFkXij07GgQ4Rj-KDZ-b_Krc5c,1734
+maidr/__init__.py,sha256=62BciXDB6GoklzRkcYKOFyZhj4umsGTIhyV_hB8TbJA,382
+maidr/api.py,sha256=F43mXWsxc7tHdlZqbRlEWkc-RjJVo_zgxCn3NiLBY58,1764
 maidr/core/__init__.py,sha256=WgxLpSEYMc4k3OyEOf1shOxfEq0ASzppEIZYmE91ThQ,25
 maidr/core/context_manager.py,sha256=6cT7ZGOApSpC-SLD2XZWWU_H08i-nfv-JUlzXOtvWYw,3374
 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
-maidr/core/enum/plot_type.py,sha256=pyfyIwlq3taqe2Z1sVUSbMsTp5QTvYBlZXsMMMclEVM,293
+maidr/core/enum/plot_type.py,sha256=CxAHUSpSHw-Fa4QI-yQHyJGPTtaCnWoR92X2ySoX-5I,315
+maidr/core/enum/smooth_keywords.py,sha256=VlpIX1BaoX8efwIrT72GIptxguTpiPtJvvJUPMoaFSQ,194
 maidr/core/figure_manager.py,sha256=e6nI5pGqH0NM3yzt2jeiae4lrBlIOhkDN92GZJ3MNmk,3988
-maidr/core/maidr.py,sha256=6Sy9pbM4YxKh9hdpbPwk5GeoRTWLPaR_DDZQgEaVmP8,12731
+maidr/core/maidr.py,sha256=t0o8dCoIcj6Oa6HGktPM7l9EN8pplvZX-Xdtp8hg19U,13996
 maidr/core/plot/__init__.py,sha256=xDIpRGM-4DfaSSL3nKcXrjdMecCHJ6en4K4nA_fPefQ,83
 maidr/core/plot/barplot.py,sha256=1HfoqyDGKIXkYQnCHN83Ye_faKpNQ3R4wjlbjD5jUyk,2092
-maidr/core/plot/boxplot.py,sha256=FjXiRdMfNj2czKs0vr8hPXr5SSu1CowyL9ZdWGbcC6s,9353
+maidr/core/plot/boxplot.py,sha256=i11GdNuz_c-hilmhydu3ah-bzyVdFoBkNvRi5lpMrrY,9946
 maidr/core/plot/grouped_barplot.py,sha256=bRcQcvwkF3Q3aZ3PlhbZ6bHI_AfcqdKUMVvlLL94wXM,2078
 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=_Sg290rk5h1LvtdaY_VKraTLXyiXGi58t-WxLFht5Ds,3331
 maidr/core/plot/maidr_plot.py,sha256=B6hjsu-jSWlevEqJawgwjMOJr51nBBNh7yqJdSTkNhw,3681
-maidr/core/plot/maidr_plot_factory.py,sha256=QGcHK_oquY_M2_KJVEtc5-rBAD-gm7KI1kSD7cduHzg,1691
+maidr/core/plot/maidr_plot_factory.py,sha256=vhBwozPbNLJyz4EqNmcTGZ87tIUCyHCyiAEZpX_Ztfk,1825
+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
@@ -24,20 +26,25 @@ maidr/patch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maidr/patch/barplot.py,sha256=nxgBWBMUyf3eAW56CN5EKYYy3vsTgEPRlcvNYS3-WiU,2479
 maidr/patch/boxplot.py,sha256=Mcz94pSf7PT3SyRsI8TDrIKVdEmiiUQouXvd05mtnfw,2846
 maidr/patch/clear.py,sha256=2Sc4CIt5jRGkew3TxFsBZm-uowC9yDSxtraEcXZjmGw,396
-maidr/patch/common.py,sha256=bRe4jruUvCIwp1t1E8Q3OuQ0eEyHgpMjXVpsPBZj4C8,843
+maidr/patch/common.py,sha256=RV2NayjPmcWJVhZJV7nmBCjcH7MPDhW_fIluTOPAATk,880
 maidr/patch/heatmap.py,sha256=uxLLg530Ql9KVC5rxk8vnwPHXBWWHwYgJRkyHY-tJzs,1048
 maidr/patch/highlight.py,sha256=I1dGFHJAnVd0AHVnMJzk_TE8BC8Uv-I6fTzSrJLU5QM,1155
-maidr/patch/histogram.py,sha256=tnyKkTMuzDXdyQBywhpHZgH3i2mXzOCSyfUSRM0tfUg,1315
-maidr/patch/lineplot.py,sha256=_EyqOp8BcO-kGq9sn8PyNQ8-Bz0FsnHAufXRkTGQzBw,1025
+maidr/patch/histogram.py,sha256=k3N0RUf1SQ2402pwbaY5QyS98KnLWvr9glCHQw9NTko,2378
+maidr/patch/kdeplot.py,sha256=qv-OKzuop2aTrkZgUe2OnLxvV-KMyeXt1Td0_uZeHzE,2338
+maidr/patch/lineplot.py,sha256=BCc3tyTrQbdLPUDWIO7hu4h1W71JRPSt2d4tYP54Li4,1085
+maidr/patch/regplot.py,sha256=Ciz43C5XZfWK6wtVWrlV0WNz4R__rcgdqVE9OCaXXRk,3236
 maidr/patch/scatterplot.py,sha256=kln6zZwjVsdQzICalo-RnBOJrx1BnIB2xYUwItHvSNY,525
 maidr/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maidr/util/dedup_utils.py,sha256=RpgPL5p-3oULUHaTCZJaQKhPHfyPkvBLHMt8lAGpJ5A,438
 maidr/util/environment.py,sha256=NJzbcFUCIk7OF29eIae8jyHax9p8fQgFLmxM6Af0fUY,4465
 maidr/util/mixin/__init__.py,sha256=aGJZNhtWh77yIVPc7ipIZm1OajigjMtCWYKPuDWTC-c,217
 maidr/util/mixin/extractor_mixin.py,sha256=oHtwpmS5kARvaLrSO3DKTPQxyFUw9nOcKN7rzTj1q4g,5192
 maidr/util/mixin/merger_mixin.py,sha256=V0qLw_6DUB7X6CQ3BCMpsCQX_ZuwAhoSTm_E4xAJFKM,712
+maidr/util/regression_line_utils.py,sha256=P8RQLixTby2JLz73XZgNiu96C2Ct3pNe4ENRWOjgT8M,509
+maidr/util/svg_utils.py,sha256=2gyzBtNKFHs0utrw1iOlxTmznzivOWQMV2aW8zu2c8E,1442
 maidr/widget/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maidr/widget/shiny.py,sha256=wrrw2KAIpE_A6CNQGBtNHauR1DjenA_n47qlFXX9_rk,745
-maidr-0.25.2.dist-info/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-maidr-0.25.2.dist-info/METADATA,sha256=bcTfPjzmkbtcZ1BrmGobbx4tTmQTqHURF8dWFHZpM6A,2703
-maidr-0.25.2.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-maidr-0.25.2.dist-info/RECORD,,
+maidr-1.1.0.dist-info/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+maidr-1.1.0.dist-info/METADATA,sha256=4dAbCUDrTHNIRUmgUuj6_7VI-X1KbzEm6tlmxAyRp1g,2748
+maidr-1.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+maidr-1.1.0.dist-info/RECORD,,

{maidr-0.25.2.dist-info → maidr-1.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any