maidr 0.19.1__tar.gz → 0.21.0__tar.gz

{maidr-0.19.1 → maidr-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: maidr
-Version: 0.19.1
+Version: 0.21.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

{maidr-0.19.1 → maidr-0.21.0}/maidr/__init__.py

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

{maidr-0.19.1 → maidr-0.21.0}/maidr/api.py

@@ -20,12 +20,10 @@ def render(plot: Any) -> Tag:
 
 def show(plot: Any, renderer: Literal["auto", "ipython", "browser"] = "auto") -> object:
     ax = FigureManager.get_axes(plot)
-    htmls = []
     if isinstance(ax, list):
         for axes in ax:
             maidr = FigureManager.get_maidr(axes.get_figure())
-            htmls.append(maidr.render())
-        return htmls[-1].show(renderer)
+        return maidr.show(renderer)
     else:
         maidr = FigureManager.get_maidr(ax.get_figure())
         return maidr.show(renderer)

{maidr-0.19.1 → maidr-0.21.0}/maidr/core/context_manager.py

@@ -77,8 +77,9 @@ class HighlightContextManager:
     _instance = None
     _lock = threading.Lock()
 
-    _maidr_element = contextvars.ContextVar("_maidr_element", default=False)
-    _elements = contextvars.ContextVar("elements", default=[])
+    elements = {}
+    elements_to_highlight = []
+    selector_ids = []
 
     def __new__(cls):
         if not cls._instance:
@@ -88,31 +89,34 @@ class HighlightContextManager:
         return cls._instance
 
     @classmethod
-    def is_maidr_element(cls):
-        return cls._maidr_element.get()
+    def is_maidr_element(cls, id):
+        return id in cls.elements
+
+    @classmethod
+    def get_selector_id(cls, id):
+        return cls.elements[id]
 
     @classmethod
     @contextlib.contextmanager
-    def set_maidr_element(cls, element):
-        if element not in cls._elements.get():
+    def set_maidr_element(cls, element, id):
+        if element not in cls.elements_to_highlight:
             yield
             return
 
-        token_maidr_element = cls._maidr_element.set(True)
         try:
+            cls.elements[id] = cls.selector_ids[
+                cls.elements_to_highlight.index(element)
+            ]
             yield
         finally:
-            cls._maidr_element.reset(token_maidr_element)
-            # Remove element from the context list after tagging
-            new_elements = cls._elements.get().copy()
-            new_elements.remove(element)
-            cls._elements.set(new_elements)
+            del cls.elements[id]
 
     @classmethod
     @contextlib.contextmanager
-    def set_maidr_elements(cls, elements: list):
-        token_paths = cls._elements.set(elements)
+    def set_maidr_elements(cls, elements: list, selector_ids: list):
+        cls.elements_to_highlight = elements
+        cls.selector_ids = selector_ids
         try:
             yield
         finally:
-            cls._elements.reset(token_paths)
+            cls.elements_to_highlight.clear()

{maidr-0.19.1 → maidr-0.21.0}/maidr/core/enum/maidr_key.py

@@ -5,12 +5,13 @@ class MaidrKey(str, Enum):
     # Maidr info keys.
     ID = "id"
     ORIENTATION = "orientation"
-    SELECTOR = "selector"
+    SELECTOR = "selectors"
     TYPE = "type"
 
     # Plot data keys.
     AXES = "axes"
     DATA = "data"
+    POINTS = "points"
     LEVEL = "level"
     X = "x"
     Y = "y"
@@ -22,13 +23,13 @@ class MaidrKey(str, Enum):
     TITLE = "title"
 
     # Box plot keys.
-    LOWER_OUTLIER = "lower_outlier"
+    LOWER_OUTLIER = "lowerOutliers"
     MIN = "min"
     MAX = "max"
     Q1 = "q1"
     Q2 = "q2"
     Q3 = "q3"
-    UPPER_OUTLIER = "upper_outlier"
+    UPPER_OUTLIER = "upperOutliers"
 
     # Grouped bar and heatmap plot keys.
     FILL = "fill"

{maidr-0.19.1 → maidr-0.21.0}/maidr/core/figure_manager.py

@@ -61,6 +61,7 @@ class FigureManager:
         maidr = cls._get_maidr(ax.get_figure(), plot_type)
         plot = MaidrPlotFactory.create(ax, plot_type, **kwargs)
         maidr.plots.append(plot)
+        maidr.selector_ids.append(Maidr._unique_id())
         return maidr
 
     @classmethod

{maidr-0.19.1 → maidr-0.21.0}/maidr/core/maidr.py

@@ -11,6 +11,7 @@ from typing import Any, Literal
 from htmltools import HTML, HTMLDocument, Tag, tags
 from lxml import etree
 from matplotlib.figure import Figure
+from matplotlib.patches import Rectangle
 
 from maidr.core.context_manager import HighlightContextManager
 from maidr.core.enum.maidr_key import MaidrKey
@@ -45,7 +46,7 @@ class Maidr:
         self._fig = fig
         self._plots = []
         self.maidr_id = None
-        self.selector_id = Maidr._unique_id()
+        self.selector_ids = []
         self.plot_type = plot_type
 
     @property
@@ -123,13 +124,15 @@ class Maidr:
     def _create_html_tag(self) -> Tag:
         """Create the MAIDR HTML using HTML tags."""
         tagged_elements = [element for plot in self._plots for element in plot.elements]
-        with HighlightContextManager.set_maidr_elements(tagged_elements):
+        selector_ids = []
+        for i, plot in enumerate(self._plots):
+            for _ in plot.elements:
+                selector_ids.append(self.selector_ids[i])
+
+        with HighlightContextManager.set_maidr_elements(tagged_elements, selector_ids):
             svg = self._get_svg()
         maidr = f"\nlet maidr = {json.dumps(self._flatten_maidr(), indent=2)}\n"
 
-        # In SVG we will replace maidr=id with the unique id.
-        svg = svg.replace('maidr="true"', f'maidr="{self.selector_id}"')
-
         # Inject plot's svg and MAIDR structure into html tag.
         return Maidr._inject_plot(svg, maidr, self.maidr_id)
 
@@ -147,23 +150,30 @@ class Maidr:
             if self.plot_type in (PlotType.LINE, PlotType.DODGED, PlotType.STACKED):
                 self._plots = [self._plots[0]]
             maidr = [plot.schema for plot in self._plots]
-            for plot in maidr:
-                if MaidrKey.SELECTOR in plot:
-                    plot[MaidrKey.SELECTOR] = plot[MaidrKey.SELECTOR].replace(
-                        "maidr='true'", f"maidr='{self.selector_id}'"
-                    )
+
             return maidr if len(maidr) != 1 else maidr[0]
 
         # Now let's start building the maidr object for the newer TypeScript engine
 
+        if self.plot_type in (PlotType.DODGED, PlotType.STACKED):
+            self._plots = [self._plots[0]]
+
         plot_schemas = []
 
-        for plot in self._plots:
+        for i, plot in enumerate(self._plots):
             schema = plot.schema
+
             if MaidrKey.SELECTOR in schema:
-                schema[MaidrKey.SELECTOR] = schema[MaidrKey.SELECTOR].replace(
-                    "maidr='true'", f"maidr='{self.selector_id}'"
-                )
+                if isinstance(schema[MaidrKey.SELECTOR], str):
+                    schema[MaidrKey.SELECTOR] = schema[MaidrKey.SELECTOR].replace(
+                        "maidr='true'", f"maidr='{self.selector_ids[i]}'"
+                    )
+                if isinstance(schema[MaidrKey.SELECTOR], list):
+                    for j in range(len(schema[MaidrKey.SELECTOR])):
+                        schema[MaidrKey.SELECTOR][j] = schema[MaidrKey.SELECTOR][
+                            j
+                        ].replace("maidr='true'", f"maidr='{self.selector_ids[i]}'")
+
             plot_schemas.append(
                 {
                     "schema": schema,
@@ -211,10 +221,6 @@ class Maidr:
         root_svg = None
         # Find the `svg` tag and set unique id if not present else use it.
         for element in tree_svg.iter(tag="{http://www.w3.org/2000/svg}svg"):
-            _id = Maidr._unique_id()
-            self._set_maidr_id(_id)
-            if "id" not in element.attrib:
-                element.attrib["id"] = _id
             if "maidr-data" not in element.attrib:
                 element.attrib["maidr-data"] = json.dumps(
                     self._flatten_maidr(), indent=2

{maidr-0.19.1 → maidr-0.21.0}/maidr/core/plot/barplot.py

@@ -68,7 +68,6 @@ class BarPlot(MaidrPlot, ContainerExtractorMixin, LevelExtractorMixin, DictMerge
         if len(plot) != len(level):
             return None
 
-        # Tag the elements for highlighting.
         self._elements.extend(plot)
 
         return [float(patch.get_height()) for patch in plot]

{maidr-0.19.1 → maidr-0.21.0}/maidr/core/plot/boxplot.py

@@ -138,22 +138,6 @@ class BoxPlot(
         box_orientation = {MaidrKey.ORIENTATION: self._orientation}
         return DictMergerMixin.merge_dict(base_schema, box_orientation)
 
-    def _extract_axes_data(self) -> dict:
-        base_ax_schema = super()._extract_axes_data()
-        if self._orientation == "vert":
-            box_ax_schema = {
-                MaidrKey.X: {
-                    MaidrKey.LEVEL: self.extract_level(self.ax, MaidrKey.X),
-                },
-            }
-        else:
-            box_ax_schema = {
-                MaidrKey.Y: {
-                    MaidrKey.LEVEL: self.extract_level(self.ax, MaidrKey.Y),
-                }
-            }
-        return self.merge_dict(base_ax_schema, box_ax_schema)
-
     def _extract_plot_data(self) -> list:
         data = self._extract_bxp_maidr(self._bxp_stats)
 
@@ -171,17 +155,27 @@ class BoxPlot(
         caps = self._bxp_extractor.extract_caps(bxp_stats["caps"])
         medians = self._bxp_extractor.extract_medians(bxp_stats["medians"])
         outliers = self._bxp_extractor.extract_outliers(bxp_stats["fliers"], caps)
-
-        for whisker, cap, median, outlier in zip(whiskers, caps, medians, outliers):
+        levels = (
+            self.extract_level(self.ax, MaidrKey.X)
+            if self._orientation == "vert"
+            else self.extract_level(self.ax, MaidrKey.Y)
+        )
+        if levels is None:
+            levels = []
+
+        for whisker, cap, median, outlier, level in zip(
+            whiskers, caps, medians, outliers, levels
+        ):
             bxp_maidr.append(
                 {
-                    MaidrKey.LOWER_OUTLIER.value: outlier["lower_outlier"],
+                    MaidrKey.LOWER_OUTLIER.value: outlier[MaidrKey.LOWER_OUTLIER.value],
                     MaidrKey.MIN.value: cap["min"],
                     MaidrKey.Q1.value: whisker["q1"],
                     MaidrKey.Q2.value: median,
                     MaidrKey.Q3.value: whisker["q3"],
                     MaidrKey.MAX.value: cap["max"],
-                    MaidrKey.UPPER_OUTLIER.value: outlier["upper_outlier"],
+                    MaidrKey.UPPER_OUTLIER.value: outlier[MaidrKey.UPPER_OUTLIER.value],
+                    MaidrKey.FILL.value: level,
                 }
             )
 

{maidr-0.19.1 → maidr-0.21.0}/maidr/core/plot/grouped_barplot.py

@@ -23,13 +23,9 @@ class GroupedBarPlot(
     def _extract_axes_data(self) -> dict:
         base_ax_schema = super()._extract_axes_data()
         grouped_ax_schema = {
-            MaidrKey.X.value: {
-                MaidrKey.LEVEL.value: self.extract_level(self.ax, MaidrKey.X),
-            },
-            MaidrKey.FILL.value: {
-                MaidrKey.LABEL.value: "Fill",
-                MaidrKey.LEVEL.value: self.extract_level(self.ax, MaidrKey.FILL),
-            },
+            MaidrKey.X.value: self.ax.get_xlabel(),
+            MaidrKey.Y.value: self.ax.get_ylabel(),
+            MaidrKey.FILL.value: self.extract_level(self.ax, MaidrKey.FILL),
         }
         return self.merge_dict(base_ax_schema, grouped_ax_schema)
 
@@ -54,14 +50,15 @@ class GroupedBarPlot(
         for container in plot:
             if len(x_level) != len(container.patches):
                 return None
-
+            container_data = []
             for x, y in zip(x_level, container.patches):
-                data.append(
+                container_data.append(
                     {
                         MaidrKey.X.value: x,
                         MaidrKey.FILL.value: container.get_label(),
                         MaidrKey.Y.value: float(y.get_height()),
                     }
                 )
+            data.append(container_data)
 
         return data

{maidr-0.19.1 → maidr-0.21.0}/maidr/core/plot/heatmap.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import numpy.ma as ma
-
 from matplotlib.axes import Axes
 from matplotlib.cm import ScalarMappable
 from matplotlib.collections import QuadMesh
@@ -36,23 +35,24 @@ class HeatPlot(
     def _extract_axes_data(self) -> dict:
         base_ax_schema = super()._extract_axes_data()
         heat_ax_schema = {
-            MaidrKey.X: {
-                MaidrKey.LEVEL: self.extract_level(self.ax, MaidrKey.X),
-            },
-            MaidrKey.Y: {
-                MaidrKey.LEVEL: self.extract_level(self.ax, MaidrKey.Y),
-            },
+            MaidrKey.X: self.ax.get_xlabel(),
+            MaidrKey.Y: self.ax.get_ylabel(),
+            MaidrKey.FILL: self._fill_label,
         }
         return self.merge_dict(base_ax_schema, heat_ax_schema)
 
-    def _extract_plot_data(self) -> list[list]:
+    def _extract_plot_data(self) -> dict:
         plot = self.extract_scalar_mappable(self.ax)
         data = self._extract_scalar_mappable_data(plot)
 
         if data is None:
             raise ExtractionError(self.type, plot)
 
-        return data
+        return {
+            MaidrKey.POINTS: data,
+            MaidrKey.X: self.extract_level(self.ax, MaidrKey.X),
+            MaidrKey.Y: self.extract_level(self.ax, MaidrKey.Y),
+        }
 
     def _extract_scalar_mappable_data(
         self, sm: ScalarMappable | None

{maidr-0.19.1 → maidr-0.21.0}/maidr/core/plot/lineplot.py

@@ -42,8 +42,10 @@ class MultiLinePlot(MaidrPlot, LineExtractorMixin):
     def __init__(self, ax: Axes, **kwargs):
         super().__init__(ax, PlotType.LINE)
 
-    def _get_selector(self) -> str:
-        return "g[maidr='true'] > path"
+    def _get_selector(self) -> str | list[str]:
+        if Environment.get_engine() == "js":
+            return "g[maidr='true'] > path"
+        return ["g[maidr='true'] > path"]
 
     def _extract_plot_data(self) -> list[dict]:
         plot = self.extract_lines(self.ax)

{maidr-0.19.1 → maidr-0.21.0}/maidr/core/plot/maidr_plot.py

@@ -66,7 +66,7 @@ class MaidrPlot(ABC):
 
     def _get_selector(self) -> str:
         """Return the CSS selector for highlighting elements."""
-        return "path[maidr='true']"
+        return "g[maidr='true'] > path"
 
     def _extract_axes_data(self) -> dict:
         """Extract the plot's axes data"""

{maidr-0.19.1 → maidr-0.21.0}/maidr/core/plot/scatterplot.py

@@ -7,6 +7,7 @@ from matplotlib.collections import PathCollection
 from maidr.core.enum import MaidrKey, PlotType
 from maidr.core.plot import MaidrPlot
 from maidr.exception import ExtractionError
+from maidr.util.environment import Environment
 from maidr.util.mixin import CollectionExtractorMixin
 
 
@@ -14,8 +15,10 @@ class ScatterPlot(MaidrPlot, CollectionExtractorMixin):
     def __init__(self, ax: Axes) -> None:
         super().__init__(ax, PlotType.SCATTER)
 
-    def _get_selector(self) -> str:
-        return "g[maidr='true'] > use"
+    def _get_selector(self) -> str | list[str]:
+        if Environment.get_engine() == "js":
+            return "g[maidr='true'] > use"
+        return ["g[maidr='true'] > use"]
 
     def _extract_plot_data(self) -> list[dict]:
         plot = self.extract_collection(self.ax, PathCollection)
@@ -35,12 +38,8 @@ class ScatterPlot(MaidrPlot, CollectionExtractorMixin):
 
         return [
             {
-                "points": [
-                    {
-                        MaidrKey.X: float(x),
-                        MaidrKey.Y: float(y),
-                    }
-                    for x, y in ma.getdata(plot.get_offsets())
-                ]
+                MaidrKey.X: float(x),
+                MaidrKey.Y: float(y),
             }
+            for x, y in ma.getdata(plot.get_offsets())
         ]

{maidr-0.19.1 → maidr-0.21.0}/maidr/patch/highlight.py

@@ -1,24 +1,28 @@
 from __future__ import annotations
 
-import wrapt
+import uuid
 
+import wrapt
+from matplotlib.backends.backend_svg import XMLWriter
 from matplotlib.collections import PathCollection, QuadMesh
+from matplotlib.figure import Figure
 from matplotlib.lines import Line2D
 from matplotlib.patches import Patch
-from matplotlib.backends.backend_svg import XMLWriter
 
 from maidr.core.context_manager import HighlightContextManager
 
 
 @wrapt.patch_function_wrapper(XMLWriter, "start")
-def inject_maidr_attribute(wrapped, _, args, kwargs):
-    if HighlightContextManager.is_maidr_element():
-        kwargs["maidr"] = "true"
+def inject_maidr_attribute(wrapped, instance, args, kwargs):
+    if HighlightContextManager.is_maidr_element(kwargs.get("id")):
+        kwargs["maidr"] = HighlightContextManager.get_selector_id(kwargs.get("id"))
     return wrapped(*args, **kwargs)
 
 
 def tag_elements(wrapped, instance, args, kwargs):
-    with HighlightContextManager.set_maidr_element(instance):
+    id = str(uuid.uuid4())
+    instance.set_gid(id)
+    with HighlightContextManager.set_maidr_element(instance, id):
         return wrapped(*args, **kwargs)
 
 

{maidr-0.19.1 → maidr-0.21.0}/maidr/util/environment.py

@@ -4,7 +4,7 @@ from typing import Literal
 
 
 class Environment:
-    _engine = "js"
+    _engine = "ts"
 
     @classmethod
     def _set_engine(cls, engine: Literal["js", "ts"]) -> None:

{maidr-0.19.1 → maidr-0.21.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "maidr"
-version = "0.19.1"
+version = "0.21.0"
 description = "Multimodal Access and Interactive Data Representations"
 authors = [
     "JooYoung Seo <jseo1005@illinois.edu>",