maidr 1.1.0__tar.gz → 1.2.1__tar.gz

{maidr-1.1.0 → maidr-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: maidr
-Version: 1.1.0
+Version: 1.2.1
 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,6 +29,7 @@ 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)

{maidr-1.1.0 → maidr-1.2.1}/maidr/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.1.0"
+__version__ = "1.2.1"
 
 from .api import close, render, save_html, show, stacked
 from .core import Maidr
@@ -6,6 +6,7 @@ from .core.enum import PlotType
 from .patch import (
     barplot,
     boxplot,
+    candlestick,
     clear,
     heatmap,
     highlight,

{maidr-1.1.0 → maidr-1.2.1}/maidr/core/enum/plot_type.py

@@ -14,3 +14,4 @@ class PlotType(str, Enum):
     SCATTER = "point"
     STACKED = "stacked_bar"
     SMOOTH = "smooth"
+    CANDLESTICK = "candlestick"

{maidr-1.1.0 → maidr-1.2.1}/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.2.1/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.1.0 → maidr-1.2.1}/maidr/core/plot/maidr_plot_factory.py

@@ -5,6 +5,7 @@ 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
@@ -30,22 +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(ax, **kwargs)
+            return SmoothPlot(single_ax, **kwargs)
         else:
             raise TypeError(f"Unsupported plot type: {plot_type}.")

{maidr-1.1.0 → maidr-1.2.1}/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.1/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.1.0 → maidr-1.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "maidr"
-version = "1.1.0"
+version = "1.2.1"
 description = "Multimodal Access and Interactive Data Representations"
 authors = [
     "JooYoung Seo <jseo1005@illinois.edu>",
@@ -43,6 +43,7 @@ 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]
@@ -72,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 = [