maidr 1.8.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

maidr/__init__.py

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

maidr/api.py

@@ -14,12 +14,12 @@ from maidr.core.figure_manager import FigureManager
 def _get_plot_or_current(plot: Any | None) -> Any:
     """
     Get the plot object or current matplotlib figure if plot is None.
-    
+
     Parameters
     ----------
     plot : Any or None
         The plot object. If None, returns the current matplotlib figure.
-        
+
     Returns
     -------
     Any
@@ -28,7 +28,7 @@ def _get_plot_or_current(plot: Any | None) -> Any:
     if plot is None:
         # Lazy import matplotlib.pyplot when needed
         import matplotlib.pyplot as plt
-        
+
         return plt.gcf()
     return plot
 
@@ -48,7 +48,7 @@ def render(plot: Any | None = None) -> Tag:
         The rendered HTML representation of the plot.
     """
     plot = _get_plot_or_current(plot)
-    
+
     ax = FigureManager.get_axes(plot)
     if isinstance(ax, list):
         for axes in ax:
@@ -82,7 +82,7 @@ def show(
         The display result.
     """
     plot = _get_plot_or_current(plot)
-    
+
     ax = FigureManager.get_axes(plot)
     if isinstance(ax, list):
         for axes in ax:
@@ -95,10 +95,11 @@ def show(
 
 def save_html(
     plot: Any | None = None,
-    *, 
+    *,
     file: str,
-    lib_dir: str | None = "lib", 
-    include_version: bool = True
+    lib_dir: str | None = "lib",
+    include_version: bool = True,
+    data_in_svg: bool = True,
 ) -> str:
     """
     Save a MAIDR plot as HTML file.
@@ -113,6 +114,8 @@ def save_html(
         Directory name for libraries.
     include_version : bool, default True
         Whether to include version information.
+    data_in_svg : bool, default True
+        Controls where the MAIDR JSON payload is placed in the HTML or SVG.
 
     Returns
     -------
@@ -120,19 +123,21 @@ def save_html(
         The path to the saved HTML file.
     """
     plot = _get_plot_or_current(plot)
-    
+
     ax = FigureManager.get_axes(plot)
     htmls = []
     if isinstance(ax, list):
         for axes in ax:
             maidr = FigureManager.get_maidr(axes.get_figure())
-            htmls.append(maidr._create_html_doc(use_iframe=False))
+            htmls.append(maidr._create_html_doc(use_iframe=False, data_in_svg=data_in_svg))
         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)
+        return maidr.save_html(
+            file, lib_dir=lib_dir, include_version=include_version, data_in_svg=data_in_svg
+        )
 
 
 def stacked(plot: Axes | BarContainer) -> Maidr:
@@ -150,6 +155,6 @@ def close(plot: Any | None = None) -> None:
         The plot object to close. If None, uses the current matplotlib figure.
     """
     plot = _get_plot_or_current(plot)
-    
+
     ax = FigureManager.get_axes(plot)
     FigureManager.destroy(ax.get_figure())

maidr/core/maidr.py

@@ -72,7 +72,12 @@ class Maidr:
         return self._create_html_tag(use_iframe=True)
 
     def save_html(
-        self, file: str, *, lib_dir: str | None = "lib", include_version: bool = True
+        self,
+        file: str,
+        *,
+        lib_dir: str | None = "lib",
+        include_version: bool = True,
+        data_in_svg: bool = True,
     ) -> str:
         """
         Save the HTML representation of the figure with MAIDR to a file.
@@ -86,9 +91,11 @@ class Maidr:
             (relative to the file's directory).
         include_version : bool, default=True
             Whether to include the version number in the dependency folder name.
+        data_in_svg : bool, default=True
+            Controls where the MAIDR JSON payload is placed in the output HTML or SVG.
         """
         html = self._create_html_doc(
-            use_iframe=False
+            use_iframe=False, data_in_svg=data_in_svg
         )  # Always use direct HTML for saving
         return html.save_html(file, libdir=lib_dir, include_version=include_version)
 
@@ -180,8 +187,17 @@ class Maidr:
         else:
             webbrowser.open(f"file://{html_file_path}")
 
-    def _create_html_tag(self, use_iframe: bool = True) -> Tag:
-        """Create the MAIDR HTML using HTML tags."""
+    def _create_html_tag(self, use_iframe: bool = True, data_in_svg: bool = True) -> Tag:
+        """Create the MAIDR HTML using HTML tags.
+
+        Parameters
+        ----------
+        use_iframe : bool, default=True
+            Whether to render the plot inside an iframe (for notebooks and similar envs).
+        data_in_svg : bool, default=True
+            If True, the MAIDR JSON is embedded in the root <svg> under attribute 'maidr'.
+            If False, a <script>var maidr = {...}</script> tag is injected instead.
+        """
         tagged_elements: list[Any] = [
             element for plot in self._plots for element in plot.elements
         ]
@@ -191,16 +207,31 @@ class Maidr:
             for _ in plot.elements:
                 selector_ids.append(self.selector_ids[i])
 
+        # Build schema once so id stays consistent across SVG and global var
+        schema = self._flatten_maidr()
+
         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"
+            svg = self._get_svg(embed_data=data_in_svg, schema=schema)
+
+        # Generate external payload if data is not embedded in SVG
+        maidr = None
+        if not data_in_svg:
+            maidr = f"\nvar maidr = {json.dumps(schema, indent=2)}\n"
 
         # Inject plot's svg and MAIDR structure into html tag.
         return Maidr._inject_plot(svg, maidr, self.maidr_id, use_iframe)
 
-    def _create_html_doc(self, use_iframe: bool = True) -> HTMLDocument:
-        """Create an HTML document from Tag objects."""
-        return HTMLDocument(self._create_html_tag(use_iframe), lang="en")
+    def _create_html_doc(self, use_iframe: bool = True, data_in_svg: bool = True) -> HTMLDocument:
+        """Create an HTML document from Tag objects.
+
+        Parameters
+        ----------
+        use_iframe : bool, default=True
+            Whether to render the plot inside an iframe (for notebooks and similar envs).
+        data_in_svg : bool, default=True
+            See _create_html_tag for details on payload placement strategy.
+        """
+        return HTMLDocument(self._create_html_tag(use_iframe, data_in_svg), lang="en")
 
     def _merge_plots_by_subplot_position(self) -> list[MaidrPlot]:
         """
@@ -312,10 +343,23 @@ class Maidr:
                 for cell in subplot_grid[i]
             ]
 
-        return {"id": Maidr._unique_id(), "subplots": subplot_grid}
+        return {
+            "id": Maidr._unique_id(),
+            "subplots": subplot_grid,
+        }
 
-    def _get_svg(self) -> HTML:
-        """Extract the chart SVG from ``matplotlib.figure.Figure``."""
+    def _get_svg(self, embed_data: bool = True, schema: dict | None = None) -> HTML:
+        """Extract the chart SVG from ``matplotlib.figure.Figure``.
+
+        Parameters
+        ----------
+        embed_data : bool, default=True
+            If True, embed the MAIDR JSON schema as an attribute named 'maidr' on
+            the root <svg> element. If False, do not embed JSON in the SVG.
+        schema : dict | None, default=None
+            If provided, this schema will be used (ensuring a consistent id across
+            the page). If None, a new schema will be generated.
+        """
         svg_buffer = io.StringIO()
         self._fig.savefig(svg_buffer, format="svg")
         str_svg = svg_buffer.getvalue()
@@ -323,12 +367,14 @@ class Maidr:
         etree.register_namespace("svg", "http://www.w3.org/2000/svg")
         tree_svg = etree.fromstring(str_svg.encode(), parser=None)
         root_svg = None
-        # Find the `svg` tag and set unique id if not present else use it.
+        # Find the `svg` tag and optionally embed MAIDR data.
         for element in tree_svg.iter(tag="{http://www.w3.org/2000/svg}svg"):
-            if "maidr-data" not in element.attrib:
-                element.attrib["maidr-data"] = json.dumps(
-                    self._flatten_maidr(), indent=2
-                )
+            current_schema = schema if schema is not None else self._flatten_maidr()
+            # Ensure SVG id matches schema id in both modes
+            if isinstance(current_schema, dict) and "id" in current_schema:
+                element.attrib["id"] = str(current_schema["id"])  # ensure match
+            if embed_data:
+                element.attrib["maidr"] = json.dumps(current_schema, indent=2)
             root_svg = element
             break
 
@@ -355,36 +401,41 @@ class Maidr:
         return str(uuid.uuid4())
 
     @staticmethod
-    def _inject_plot(plot: HTML, maidr: str, maidr_id, use_iframe: bool = True) -> Tag:
+    def _inject_plot(plot: HTML, maidr: str | None, maidr_id, use_iframe: bool = True) -> Tag:
         """Embed the plot and associated MAIDR scripts into the HTML structure."""
         # Get the latest version from npm registry
         MAIDR_TS_CDN_URL = "https://cdn.jsdelivr.net/npm/maidr@latest/dist/maidr.js"
 
         script = f"""
-            if (!document.querySelector('script[src="{MAIDR_TS_CDN_URL}"]'))
-            {{
-                var script = document.createElement('script');
-                script.type = 'module';
-                script.src = '{MAIDR_TS_CDN_URL}';
-                script.addEventListener('load', function() {{
-                    window.main();
-                }});
-                document.head.appendChild(script);
-            }} else {{
-                document.addEventListener('DOMContentLoaded', function (e) {{
-                    window.main();
-                }});
-            }}
+            (function() {{
+                var existing = document.querySelector('script[src="{MAIDR_TS_CDN_URL}"]');
+                if (!existing) {{
+                    var s = document.createElement('script');
+                    s.src = '{MAIDR_TS_CDN_URL}';
+                    s.onload = function() {{ if (window.main) window.main(); }};
+                    document.head.appendChild(s);
+                }} else {{
+                    if (document.readyState === 'loading') {{
+                        document.addEventListener('DOMContentLoaded', function() {{ if (window.main) window.main(); }});
+                    }} else {{
+                        if (window.main) window.main();
+                    }}
+                }}
+            }})();
         """
 
-        base_html = tags.div(
+        children = [
             tags.link(
                 rel="stylesheet",
                 href="https://cdn.jsdelivr.net/npm/maidr@latest/dist/maidr_style.css",
-            ),
-            tags.script(script, type="text/javascript"),
-            tags.div(plot),
-        )
+            )
+        ]
+        if maidr is not None:
+            children.append(tags.script(maidr, type="text/javascript"))
+        children.append(tags.script(script, type="text/javascript"))
+        children.append(tags.div(plot))
+
+        base_html = tags.div(*children)
 
         # is_quarto = os.getenv("IS_QUARTO") == "True"
 

maidr/core/plot/candlestick.py

@@ -1,24 +1,21 @@
 from __future__ import annotations
 
-import uuid
 from typing import Union, Dict
 from matplotlib.axes import Axes
-from matplotlib.patches import Rectangle
-import numpy as np
+import pandas as pd
 
 from maidr.core.enum import PlotType
 from maidr.core.plot import MaidrPlot
 from maidr.core.enum.maidr_key import MaidrKey
 from maidr.exception import ExtractionError
-from maidr.util.mplfinance_utils import MplfinanceDataExtractor
 
 
 class CandlestickPlot(MaidrPlot):
     """
     Specialized candlestick plot class for mplfinance OHLC data.
 
-    This class handles the extraction and processing of candlestick data from mplfinance
-    plots, including proper date conversion and data validation.
+    This class extracts candlestick data directly from the original DataFrame
+    without any formatting or transformation.
     """
 
     def __init__(self, axes: list[Axes], **kwargs) -> None:
@@ -34,23 +31,17 @@ class CandlestickPlot(MaidrPlot):
             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)
 
-        # Store custom collections passed from mplfinance patch
+        # Store collections passed from mplfinance patch
         self._maidr_wick_collection = kwargs.get("_maidr_wick_collection", None)
         self._maidr_body_collection = kwargs.get("_maidr_body_collection", None)
-        self._maidr_date_nums = kwargs.get("_maidr_date_nums", None)
-        self._maidr_original_data = kwargs.get(
-            "_maidr_original_data", None
-        )  # Store original data
-        self._maidr_datetime_converter = kwargs.get("_maidr_datetime_converter", None)
+        self._maidr_original_data = kwargs.get("_maidr_original_data", None)
 
-        # Store the GID for proper selector generation (legacy/shared)
+        # Store the GID for selector generation
         self._maidr_gid = None
-        # Modern-path separate gids for body and wick
         self._maidr_body_gid = None
         self._maidr_wick_gid = None
         if self._maidr_body_collection:
@@ -62,105 +53,83 @@ class CandlestickPlot(MaidrPlot):
 
     def _extract_plot_data(self) -> list[dict]:
         """
-        Extract candlestick data from the plot.
-
-        This method processes candlestick plots from both modern (mplfinance.plot) and
-        legacy (original_flavor) pipelines, extracting OHLC data and setting up
-        highlighting elements and GIDs.
+        Extract candlestick data directly from the original DataFrame.
 
         Returns
         -------
         list[dict]
             List of dictionaries containing candlestick data with keys:
-            - 'value': Date string
+            - 'value': Date string (raw from DataFrame index)
             - 'open': Opening price (float)
             - 'high': High price (float)
             - 'low': Low price (float)
             - 'close': Closing price (float)
-            - 'volume': Volume (float, typically 0 for candlestick-only plots)
+            - 'volume': Volume (float)
         """
-
-        # Get the custom collections from kwargs
         body_collection = self._maidr_body_collection
         wick_collection = self._maidr_wick_collection
 
         if body_collection and wick_collection:
-            # Store the GIDs from the collections (modern path)
+            # Store the GIDs from the collections
             self._maidr_body_gid = body_collection.get_gid()
             self._maidr_wick_gid = wick_collection.get_gid()
-            # Keep legacy gid filled for backward compatibility
             self._maidr_gid = self._maidr_body_gid or self._maidr_wick_gid
 
             # Use the original collections for highlighting
             self._elements = [body_collection, wick_collection]
 
-            # Use datetime converter for enhanced data extraction
-            if self._maidr_datetime_converter is not None:
-                data = self._maidr_datetime_converter.extract_candlestick_data(
-                    self.axes[0], wick_collection, body_collection
-                )
-                return data
-
-            # Fallback to original detection method
-            if not self.axes:
-                return []
-
-            ax_ohlc = self.axes[0]
-
-            # Look for Rectangle patches (original_flavor candlestick)
-            body_rectangles = []
-            for patch in ax_ohlc.patches:
-                if isinstance(patch, Rectangle):
-                    body_rectangles.append(patch)
-
-            if body_rectangles:
-                # Set elements for highlighting
-                self._elements = body_rectangles
-
-                # Generate a GID for highlighting if none exists
-                if not self._maidr_gid:
-                    self._maidr_gid = f"maidr-{uuid.uuid4()}"
-                    # Set GID on all rectangles
-                    for rect in body_rectangles:
-                        rect.set_gid(self._maidr_gid)
-                # Keep a dedicated body gid for legacy dict selectors
-                self._maidr_body_gid = (
-                    getattr(self, "_maidr_body_gid", None) or self._maidr_gid
-                )
-
-                # Assign a shared gid to wick Line2D (vertical 2-point lines) on the same axis
-                wick_lines = []
-                for line in ax_ohlc.get_lines():
-                    try:
-                        xydata = line.get_xydata()
-                        if xydata is None:
-                            continue
-                        xy_arr = np.asarray(xydata)
-                        if (
-                            xy_arr.ndim == 2
-                            and xy_arr.shape[0] == 2
-                            and xy_arr.shape[1] >= 2
-                        ):
-                            x0 = float(xy_arr[0, 0])
-                            x1 = float(xy_arr[1, 0])
-                            if abs(x0 - x1) < 1e-10:
-                                wick_lines.append(line)
-                    except Exception:
-                        continue
-                if wick_lines:
-                    if not getattr(self, "_maidr_wick_gid", None):
-                        self._maidr_wick_gid = f"maidr-{uuid.uuid4()}"
-                    for line in wick_lines:
-                        line.set_gid(self._maidr_wick_gid)
-
-                # Use the utility class to extract data
-                data = MplfinanceDataExtractor.extract_rectangle_candlestick_data(
-                    body_rectangles, self._maidr_date_nums, self._maidr_original_data
-                )
-                return data
+            # Extract data directly from DataFrame
+            if self._maidr_original_data is not None and isinstance(
+                self._maidr_original_data, pd.DataFrame
+            ):
+                return self._extract_from_dataframe(self._maidr_original_data)
 
         return []
 
+    def _extract_from_dataframe(self, df: pd.DataFrame) -> list[dict]:
+        """
+        Extract candlestick data directly from DataFrame without any formatting.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            DataFrame with OHLC data and DatetimeIndex.
+
+        Returns
+        -------
+        list[dict]
+            List of candlestick data dictionaries with raw values.
+        """
+        candles = []
+
+        for i in range(len(df)):
+            try:
+                # Get date directly from index - raw representation
+                date_value = str(df.index[i])
+
+                # Get OHLC values directly from DataFrame columns
+                open_price = float(df.iloc[i]["Open"])
+                high_price = float(df.iloc[i]["High"])
+                low_price = float(df.iloc[i]["Low"])
+                close_price = float(df.iloc[i]["Close"])
+
+                # Get volume if available, otherwise 0
+                volume = float(df.iloc[i].get("Volume", 0.0))
+
+                candle_data = {
+                    "value": date_value,
+                    "open": open_price,
+                    "high": high_price,
+                    "low": low_price,
+                    "close": close_price,
+                    "volume": volume,
+                }
+                candles.append(candle_data)
+            except (KeyError, IndexError, ValueError, TypeError):
+                continue
+
+        return candles
+
     def _extract_axes_data(self) -> dict:
         """
         Extract the plot's axes data including labels.

maidr/util/datetime_conversion.py

@@ -6,18 +6,16 @@ from datetime import datetime
 
 class DatetimeConverter:
     """
-    Enhanced datetime converter that automatically detects time periods
-    and provides intelligent date/time formatting for mplfinance plots.
+    Datetime converter for mplfinance plots.
 
-    This utility automatically detects the time period of financial data and formats
-    datetime values consistently for screen reader accessibility and visual clarity.
+    This utility provides datetime value conversion for financial data visualization.
 
     Parameters
     ----------
     data : pd.DataFrame
         DataFrame with DatetimeIndex containing financial data.
     datetime_format : str, optional
-        Custom datetime format string. If None, automatic format detection is used.
+        Custom datetime format string (currently unused, kept for compatibility).
 
     Attributes
     ----------
@@ -49,14 +47,14 @@ class DatetimeConverter:
     >>>
     >>> # Get formatted datetime
     >>> formatted = converter.get_formatted_datetime(0)
-    >>> print(formatted)  # Output: "Jan 15 2024"
+    >>> print(formatted)  # Output: "2024-01-15 00:00:00"
     >>>
     >>> # For time-based data
     >>> hourly_dates = pd.date_range('2024-01-15 09:00:00', periods=3, freq='H')
     >>> df_hourly = pd.DataFrame({'Open': [3050, 3078, 3080]}, index=hourly_dates)
     >>> converter_hourly = create_datetime_converter(df_hourly)
     >>> formatted_hourly = converter_hourly.get_formatted_datetime(0)
-    >>> print(formatted_hourly)  # Output: "Jan 15 2024 09:00"
+    >>> print(formatted_hourly)  # Output: "2024-01-15 09:00:00"
     """
 
     def __init__(
@@ -164,9 +162,7 @@ class DatetimeConverter:
 
     def get_formatted_datetime(self, index: int) -> Optional[str]:
         """
-        Get formatted datetime string for given index using consistent formatting.
-
-        Always includes year for screen reader accessibility.
+        Get datetime string for given index.
 
         Parameters
         ----------
@@ -176,13 +172,13 @@ class DatetimeConverter:
         Returns
         -------
         str or None
-            Formatted datetime string or None if index is invalid.
+            Datetime string or None if index is invalid.
 
         Examples
         --------
         >>> converter = create_datetime_converter(df)
         >>> formatted = converter.get_formatted_datetime(0)
-        >>> print(formatted)  # "Jan 15 2024" for daily data
+        >>> print(formatted)  # "2024-01-15 00:00:00"
         """
         if index not in self.date_mapping:
             return None
@@ -192,7 +188,7 @@ class DatetimeConverter:
 
     def _format_datetime_custom(self, dt: datetime) -> str:
         """
-        Consistent datetime formatting with year always included.
+        Format datetime as-is using ISO format.
 
         Parameters
         ----------
@@ -202,24 +198,15 @@ class DatetimeConverter:
         Returns
         -------
         str
-            Formatted datetime string with consistent pattern.
+            Formatted datetime string in ISO format.
 
         Notes
         -----
-        Formatting rules:
-        - Daily data: "Jan 15 2024"
-        - Time-based data: "Jan 15 2024 09:00" or "Jan 15 2024 09:00:30"
-        - Seconds are only shown when they are non-zero for cleaner display.
+        Returns the datetime as a string without smart formatting.
+        Output format is "YYYY-MM-DD HH:MM:SS" (e.g., "2024-01-15 00:00:00").
         """
-        if self.time_period in ["minute", "intraday", "hour"]:
-            # Time-based data: include time with optional seconds
-            if dt.second == 0:
-                return dt.strftime("%b %d %Y %H:%M")
-            else:
-                return dt.strftime("%b %d %Y %H:%M:%S")
-        else:
-            # Daily/weekly/monthly data: just date
-            return dt.strftime("%b %d %Y")
+        # Return string representation of datetime
+        return str(dt)
 
     @property
     def date_nums(self) -> List[float]:

maidr/util/mplfinance_utils.py

@@ -2,11 +2,10 @@
 Utility functions for handling mplfinance-specific data extraction and processing.
 """
 
+import re
 import matplotlib.dates as mdates
-import numpy as np
 from matplotlib.patches import Rectangle
-from typing import List, Optional, Tuple, Any, Union
-import pandas as pd
+from typing import List, Optional
 
 
 class MplfinanceDataExtractor:
@@ -58,229 +57,6 @@ class MplfinanceDataExtractor:
 
         return formatted_data
 
-    @staticmethod
-    def extract_candlestick_data(
-        body_collection: Any,
-        wick_collection: Any,
-        date_nums: Optional[List[float]] = None,
-        original_data: Optional[Union[pd.DataFrame, pd.Series, dict]] = None,
-    ) -> List[dict]:
-        """
-        Extract candlestick data from mplfinance collections.
-
-        Parameters
-        ----------
-        body_collection : Any
-            PolyCollection containing candlestick bodies
-        wick_collection : Any
-            LineCollection containing candlestick wicks
-        date_nums : Optional[List[float]], default=None
-            List of matplotlib date numbers corresponding to the candles
-        original_data : Optional[Union[pd.DataFrame, pd.Series, dict]], default=None
-            Original DataFrame/Series/dict with OHLC data for accurate bull/bear classification
-
-        Returns
-        -------
-        List[dict]
-            List of dictionaries with OHLC data
-        """
-        if not body_collection or not hasattr(body_collection, "get_paths"):
-            return []
-
-        candles = []
-        paths = body_collection.get_paths()
-
-        for i, path in enumerate(paths):
-            if len(path.vertices) >= 4:
-                # Extract rectangle coordinates from the path
-                vertices = path.vertices
-                x_coords = vertices[:, 0]
-                y_coords = vertices[:, 1]
-
-                x_min, x_max = x_coords.min(), x_coords.max()
-                y_min, y_max = y_coords.min(), y_coords.max()
-
-                # Use date mapping if available
-                if date_nums is not None and i < len(date_nums):
-                    date_num = date_nums[i]
-                    date_str = MplfinanceDataExtractor._convert_date_num_to_string(
-                        date_num
-                    )
-                else:
-                    x_center = (x_min + x_max) / 2
-                    date_str = MplfinanceDataExtractor._convert_date_num_to_string(
-                        x_center
-                    )
-
-                # Determine if this is an up or down candle using original data
-                is_up = MplfinanceDataExtractor._determine_bull_bear_from_data(
-                    original_data, i, date_str
-                )
-
-                # Extract OHLC values
-                (
-                    open_val,
-                    close_val,
-                ) = MplfinanceDataExtractor._extract_ohlc_from_rectangle(
-                    y_min, y_max, is_up
-                )
-
-                # Estimate high and low (these would normally come from wick data)
-                high_val = y_max + (y_max - y_min) * 0.1
-                low_val = y_min - (y_max - y_min) * 0.1
-
-                candle_data = {
-                    "value": date_str,
-                    "open": round(open_val, 2),
-                    "high": round(high_val, 2),
-                    "low": round(low_val, 2),
-                    "close": round(close_val, 2),
-                    "volume": 0,  # Volume is handled separately
-                }
-
-                candles.append(candle_data)
-
-        return candles
-
-    @staticmethod
-    def extract_rectangle_candlestick_data(
-        body_rectangles: List[Rectangle],
-        date_nums: Optional[List[float]] = None,
-        original_data: Optional[Union[pd.DataFrame, pd.Series, dict]] = None,
-    ) -> List[dict]:
-        """
-        Extract candlestick data from Rectangle patches (original_flavor).
-
-        Parameters
-        ----------
-        body_rectangles : List[Rectangle]
-            List of Rectangle patches representing candlestick bodies
-        date_nums : Optional[List[float]], default=None
-            List of matplotlib date numbers corresponding to the candles
-        original_data : Optional[Union[pd.DataFrame, pd.Series, dict]], default=None
-            Original DataFrame/Series/dict with OHLC data for accurate bull/bear classification
-
-        Returns
-        -------
-        List[dict]
-            List of dictionaries with OHLC data
-        """
-        if not body_rectangles:
-            return []
-
-        candles = []
-
-        # Sort rectangles by x-coordinate
-        body_rectangles.sort(key=lambda r: r.get_x())
-
-        for i, rect in enumerate(body_rectangles):
-            x_left = rect.get_x()
-            width = rect.get_width()
-            x_center_num = x_left + width / 2.0
-
-            # Convert x coordinate to date
-            if date_nums is not None and i < len(date_nums):
-                date_str = MplfinanceDataExtractor._convert_date_num_to_string(
-                    date_nums[i]
-                )
-            else:
-                date_str = MplfinanceDataExtractor._convert_date_num_to_string(
-                    x_center_num
-                )
-
-            y_bottom = rect.get_y()
-            height = rect.get_height()
-
-            # Determine if this is an up or down candle using original data
-            is_up_candle = MplfinanceDataExtractor._determine_bull_bear_from_data(
-                original_data, i, date_str
-            )
-
-            # Extract OHLC values from rectangle
-            (
-                open_price,
-                close_price,
-            ) = MplfinanceDataExtractor._extract_ohlc_from_rectangle(
-                y_bottom, y_bottom + height, is_up_candle
-            )
-
-            # Estimate high and low
-            high_price = max(open_price, close_price) + height * 0.1
-            low_price = min(open_price, close_price) - height * 0.1
-
-            # Ensure all values are valid numbers
-            open_price = float(open_price) if not np.isnan(open_price) else 0.0
-            high_price = float(high_price) if not np.isnan(high_price) else 0.0
-            low_price = float(low_price) if not np.isnan(low_price) else 0.0
-            close_price = float(close_price) if not np.isnan(close_price) else 0.0
-
-            candle_data = {
-                "value": date_str,
-                "open": round(open_price, 2),
-                "high": round(high_price, 2),
-                "low": round(low_price, 2),
-                "close": round(close_price, 2),
-                "volume": 0,
-            }
-
-            candles.append(candle_data)
-
-        return candles
-
-    @staticmethod
-    def _determine_bull_bear_from_data(
-        original_data: Optional[Union[pd.DataFrame, pd.Series, dict]],
-        index: int,
-        date_str: str,
-    ) -> bool:
-        """
-        Determine if a candle is bullish (up) or bearish (down) using original OHLC data.
-
-        This is the most robust method as it uses the actual data rather than colors.
-
-        Parameters
-        ----------
-        original_data : Optional[Union[pd.DataFrame, pd.Series, dict]]
-            Original DataFrame/Series/dict with OHLC data
-        index : int
-            Index of the candle
-        date_str : str
-            Date string for the candle
-
-        Returns
-        -------
-        bool
-            True if bullish (close > open), False if bearish (close < open)
-        """
-        # Default to bullish if no data available
-        if original_data is None:
-            return True
-
-        try:
-            # Try to access the original data
-            if hasattr(original_data, "iloc"):
-                # It's a pandas DataFrame/Series
-                if index < len(original_data):
-                    row = original_data.iloc[index]
-                    if "Close" in row and "Open" in row:
-                        is_bullish = row["Close"] > row["Open"]
-                        return is_bullish
-
-            elif hasattr(original_data, "__getitem__"):
-                # It's a dictionary or similar
-                if "Close" in original_data and "Open" in original_data:
-                    closes = original_data["Close"]
-                    opens = original_data["Open"]
-                    if index < len(closes) and index < len(opens):
-                        is_bullish = closes[index] > opens[index]
-                        return is_bullish
-
-        except (KeyError, IndexError, AttributeError):
-            pass
-
-        # Fallback to bullish if data access fails
-        return True  # Default to bullish
-
     @staticmethod
     def clean_axis_label(label: str) -> str:
         """
@@ -299,8 +75,6 @@ class MplfinanceDataExtractor:
         if not label or not isinstance(label, str):
             return label
 
-        import re
-
         # Removes LaTeX-like scientific notation, e.g., "$10^{6}$"
         cleaned_label = re.sub(r"\s*\$.*?\$", "", label).strip()
         return cleaned_label if cleaned_label else label
@@ -318,7 +92,7 @@ class MplfinanceDataExtractor:
         Returns
         -------
         str
-            Date string in YYYY-MM-DD format or fallback index
+            Date string representation (e.g., "2024-01-15 00:00:00") or fallback index
         """
         try:
             # Check if this looks like a matplotlib date number (typically > 700000)
@@ -326,14 +100,14 @@ class MplfinanceDataExtractor:
                 date_dt = mdates.num2date(date_num)
                 if hasattr(date_dt, "replace"):
                     date_dt = date_dt.replace(tzinfo=None)
-                return date_dt.strftime("%Y-%m-%d")
+                return str(date_dt)
             elif date_num > 1000:
                 # Try converting as if it's a pandas timestamp
                 try:
                     import pandas as pd
 
                     date_dt = pd.to_datetime(date_num, unit="D")
-                    return date_dt.strftime("%Y-%m-%d")
+                    return str(date_dt)
                 except (ValueError, TypeError):
                     pass
         except (ValueError, TypeError, OverflowError):
@@ -341,75 +115,3 @@ class MplfinanceDataExtractor:
 
         # Fallback to index-based date string
         return f"date_{int(date_num):03d}"
-
-    @staticmethod
-    def convert_x_to_date(x_center_num: float, axes: Optional[List] = None) -> str:
-        """
-        Convert matplotlib x-coordinate to date string.
-
-        Parameters
-        ----------
-        x_center_num : float
-            X-coordinate value to convert
-        axes : Optional[List], optional
-            List of matplotlib axes to help with date conversion
-
-        Returns
-        -------
-        str
-            Date string in YYYY-MM-DD format or fallback
-        """
-        # First, try to get the actual dates from the axes x-axis data
-        if axes and len(axes) > 0:
-            ax = axes[0]
-            try:
-                # Get x-axis ticks which might contain the actual dates
-                x_ticks = ax.get_xticks()
-
-                # If we have x-axis ticks and they look like dates (large numbers), use them
-                if len(x_ticks) > 0 and x_ticks[0] > 1000:
-                    # Find the closest tick to our x_center_num
-                    tick_index = int(round(x_center_num))
-                    if 0 <= tick_index < len(x_ticks):
-                        actual_date_num = x_ticks[tick_index]
-
-                        # Convert the actual date number
-                        if actual_date_num > 700000:
-                            date_dt = mdates.num2date(actual_date_num)
-                            if hasattr(date_dt, "replace"):
-                                date_dt = date_dt.replace(tzinfo=None)
-                            date_str = date_dt.strftime("%Y-%m-%d")
-                            return date_str
-            except Exception:
-                pass
-
-        # Use the utility class for date conversion
-        return MplfinanceDataExtractor._convert_date_num_to_string(x_center_num)
-
-    @staticmethod
-    def _extract_ohlc_from_rectangle(
-        y_min: float, y_max: float, is_up: bool
-    ) -> Tuple[float, float]:
-        """
-        Extract open and close values from rectangle bounds.
-
-        Parameters
-        ----------
-        y_min : float
-            Minimum y value of rectangle
-        y_max : float
-            Maximum y value of rectangle
-        is_up : bool
-            Whether this is an up candle
-
-        Returns
-        -------
-        Tuple[float, float]
-            (open_price, close_price)
-        """
-        if is_up:
-            # Up candle: open at bottom, close at top
-            return y_min, y_max
-        else:
-            # Down candle: open at top, close at bottom
-            return y_max, y_min

{maidr-1.8.1.dist-info → maidr-1.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maidr
-Version: 1.8.1
+Version: 1.10.0
 Summary: Multimodal Access and Interactive Data Representations
 Project-URL: Homepage, https://xability.github.io/py-maidr
 Project-URL: Repository, https://github.com/xability/py-maidr

{maidr-1.8.1.dist-info → maidr-1.10.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-maidr/__init__.py,sha256=KlhM_Qllqa69TYYU98Ba_yfOHROB9TYO3rIbVitC1D8,415
-maidr/api.py,sha256=od539V0CKcs15FEXQo0hX_hK_A0U3noHE54obdHcTqY,4138
+maidr/__init__.py,sha256=BXkAG-4A4pF_IjbBj6cOmPTmQYICXnfPniPJ-4OHnr0,416
+maidr/api.py,sha256=WK7jfQttuPeF1q45RuF_wTciYyiFY6SyjfZVSOVkiUs,4316
 maidr/core/__init__.py,sha256=WgxLpSEYMc4k3OyEOf1shOxfEq0ASzppEIZYmE91ThQ,25
 maidr/core/context_manager.py,sha256=6cT7ZGOApSpC-SLD2XZWWU_H08i-nfv-JUlzXOtvWYw,3374
 maidr/core/figure_manager.py,sha256=t-lhe4jj2gsF5-8VUBUZOPlDutKjm_AZ8xXWJU2pFRc,5555
-maidr/core/maidr.py,sha256=0MuyPgc1CFomA87jq70GG-MSxYaMI2Z7ct2FAOGCxQM,20067
+maidr/core/maidr.py,sha256=Ye2C8tQPY1o8gfURiTyDPMWFoRT0toZOOCugKAz4uQU,22370
 maidr/core/enum/__init__.py,sha256=9ee78L0dlxEx4ulUGVlD-J23UcUZmrGu0rXms54up3c,93
 maidr/core/enum/library.py,sha256=e8ujT_L-McJWfoVJd1ty9K_2bwITnf1j0GPLsnAcHes,104
 maidr/core/enum/maidr_key.py,sha256=ljG0omqzd8K8Yk213N7i7PXGvG-IOlnE5v7o6RoGJzc,795
@@ -12,7 +12,7 @@ maidr/core/enum/smooth_keywords.py,sha256=z2kVZZ-mETWWh5reWu_hj9WkJD6WFj7_2-6s1e
 maidr/core/plot/__init__.py,sha256=xDIpRGM-4DfaSSL3nKcXrjdMecCHJ6en4K4nA_fPefQ,83
 maidr/core/plot/barplot.py,sha256=0hBgp__putezvxXc9G3qmaktmAzze3cN8pQMD9iqktE,2116
 maidr/core/plot/boxplot.py,sha256=i11GdNuz_c-hilmhydu3ah-bzyVdFoBkNvRi5lpMrrY,9946
-maidr/core/plot/candlestick.py,sha256=ofvlUwtzaaopvv6VjNDf1IZODbu1UkMHsi1zdvcG-Yo,10120
+maidr/core/plot/candlestick.py,sha256=qOsYIbn2sRdGE2ES-YJ-Rwhu4NsScHs52mtKe6Bl7_A,8236
 maidr/core/plot/grouped_barplot.py,sha256=odZ52Pl22nb9cWKD3NGsZsyFDxXdBDAEcbOj66HKp9I,4063
 maidr/core/plot/heatmap.py,sha256=yMS-31tS2GW4peds9LtZesMxmmTV_YfqYO5M_t5KasQ,2521
 maidr/core/plot/histogram.py,sha256=QV5W-6ZJQQcZsrM91JJBX-ONktJzH7yg_et5_bBPfQQ,1525
@@ -40,10 +40,10 @@ maidr/patch/mplfinance.py,sha256=ySD32onanoMgdQkV6XlSAbVd_BQuLWuEQtpkYSEDSzA,949
 maidr/patch/regplot.py,sha256=k86ekd0E4XJ_L1u85zObuDnxuXlM83z7tKtyXRTj2rI,3240
 maidr/patch/scatterplot.py,sha256=kln6zZwjVsdQzICalo-RnBOJrx1BnIB2xYUwItHvSNY,525
 maidr/util/__init__.py,sha256=eRJZfRpDX-n7UoV3JXw_9Lbfu_qNl_D0W1UTvLL-Iv4,81
-maidr/util/datetime_conversion.py,sha256=AQ8qShbEkLVo13TUkOOmtOLnOvaI05Vh5oWhgchvXSA,14478
+maidr/util/datetime_conversion.py,sha256=BF115xweGcrKyDnnjYPeScc0WgeNpCylV0Z-mYKaP4w,13769
 maidr/util/dedup_utils.py,sha256=RpgPL5p-3oULUHaTCZJaQKhPHfyPkvBLHMt8lAGpJ5A,438
 maidr/util/environment.py,sha256=C4VMyB16mqzrFxpJdxFdm40M0IZojxh60UX80680jgo,9403
-maidr/util/mplfinance_utils.py,sha256=OZe5Y7gzjdjve9DViioQvGZYTdZvz8obvN3oHElQFZw,14418
+maidr/util/mplfinance_utils.py,sha256=00YEjrCUbigZZL1j9jzOTamNnwfy5ZZmXJj65AhgNbw,3662
 maidr/util/plot_detection.py,sha256=bgLHoDcHSRwOiyKzUK3EqGwdAIhF44ocHW5ox6xYGZw,3883
 maidr/util/regression_line_utils.py,sha256=yFKr-H0whT_su2YVZwNksBLp5EC5s77sr6HUFgNcsyY,2329
 maidr/util/svg_utils.py,sha256=2gyzBtNKFHs0utrw1iOlxTmznzivOWQMV2aW8zu2c8E,1442
@@ -52,7 +52,7 @@ maidr/util/mixin/extractor_mixin.py,sha256=j2Rv2vh_gqqcxLV1ka3xsPaPAfWsX94CtKIW2
 maidr/util/mixin/merger_mixin.py,sha256=V0qLw_6DUB7X6CQ3BCMpsCQX_ZuwAhoSTm_E4xAJFKM,712
 maidr/widget/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maidr/widget/shiny.py,sha256=wrrw2KAIpE_A6CNQGBtNHauR1DjenA_n47qlFXX9_rk,745
-maidr-1.8.1.dist-info/METADATA,sha256=oi8YKhP-r2l0NN9AnBTngZFG11lQK1jtSnRsWj8osjc,3154
-maidr-1.8.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-maidr-1.8.1.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-maidr-1.8.1.dist-info/RECORD,,
+maidr-1.10.0.dist-info/METADATA,sha256=6llsnqQI7-gfp62yZJ1ucSXxf9xvrUVNtcItkoxnwnM,3155
+maidr-1.10.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+maidr-1.10.0.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+maidr-1.10.0.dist-info/RECORD,,

{maidr-1.8.1.dist-info → maidr-1.10.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any