maidr 1.9.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

maidr/__init__.py

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

maidr/core/enum/maidr_key.py

@@ -11,6 +11,7 @@ class MaidrKey(str, Enum):
     # Plot data keys.
     AXES = "axes"
     DATA = "data"
+    FORMAT = "format"
     POINTS = "points"
     LEVEL = "level"
     X = "x"

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,133 +31,106 @@ 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:
             self._maidr_gid = self._maidr_body_collection.get_gid()
             self._maidr_body_gid = self._maidr_gid
-        elif self._maidr_wick_collection:
-            self._maidr_gid = self._maidr_wick_collection.get_gid()
-            self._maidr_wick_gid = self._maidr_gid
+        if self._maidr_wick_collection:
+            self._maidr_wick_gid = self._maidr_wick_collection.get_gid()
+            if not self._maidr_gid:
+                self._maidr_gid = self._maidr_wick_gid
 
     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.
@@ -178,11 +148,7 @@ class CandlestickPlot(MaidrPlot):
         return {MaidrKey.X: x_labels, MaidrKey.Y: self.ax.get_ylabel()}
 
     def _get_selector(self) -> Union[str, Dict[str, str]]:
-        """Return selectors for highlighting candlestick elements.
-
-        - Modern path (collections present): return a dict with separate selectors for body, wickLow, wickHigh
-        - Legacy path: return a dict with body and shared wick selectors (no open/close keys)
-        """
+        """Return selectors for highlighting candlestick elements."""
         # Modern path: build structured selectors using separate gids
         if (
             self._maidr_body_collection
@@ -221,12 +187,12 @@ class CandlestickPlot(MaidrPlot):
             }
             return selectors
 
-        # Legacy path: build shared-id selectors; omit open/close
+        # Legacy path
         legacy_selectors = {}
-        if getattr(self, "_maidr_body_gid", None) or self._maidr_gid:
-            body_gid = getattr(self, "_maidr_body_gid", None) or self._maidr_gid
+        if self._maidr_body_gid or self._maidr_gid:
+            body_gid = self._maidr_body_gid or self._maidr_gid
             legacy_selectors["body"] = f"g[id='{body_gid}'] > path"
-        if getattr(self, "_maidr_wick_gid", None):
+        if self._maidr_wick_gid:
             legacy_selectors["wick"] = f"g[id='{self._maidr_wick_gid}'] > path"
         if legacy_selectors:
             return legacy_selectors
@@ -238,9 +204,12 @@ class CandlestickPlot(MaidrPlot):
         """Initialize the MAIDR schema dictionary with basic plot information."""
         base_schema = super().render()
         base_schema[MaidrKey.TITLE] = "Candlestick Chart"
-        base_schema[MaidrKey.AXES] = self._extract_axes_data()
+        # Update axes labels while preserving format from parent
+        axes_data = self._extract_axes_data()
+        if MaidrKey.AXES in base_schema and MaidrKey.FORMAT in base_schema[MaidrKey.AXES]:
+            axes_data[MaidrKey.FORMAT] = base_schema[MaidrKey.AXES][MaidrKey.FORMAT]
+        base_schema[MaidrKey.AXES] = axes_data
         base_schema[MaidrKey.DATA] = self._extract_plot_data()
-        # Include selector only if the plot supports highlighting.
         if self._support_highlighting:
             base_schema[MaidrKey.SELECTOR] = self._get_selector()
         return base_schema

maidr/core/plot/maidr_plot.py

@@ -5,12 +5,13 @@ from abc import ABC, abstractmethod
 from matplotlib.axes import Axes
 
 from maidr.core.enum import MaidrKey, PlotType
+from maidr.util.mixin import FormatExtractorMixin
 
 # uuid is used to generate unique identifiers for each plot layer in the MAIDR schema.
 import uuid
 
 
-class MaidrPlot(ABC):
+class MaidrPlot(ABC, FormatExtractorMixin):
     """
     Abstract base class for plots managed by the MAIDR system.
 
@@ -61,13 +62,21 @@ class MaidrPlot(ABC):
         """
         Generate the MAIDR schema for this plot layer, including a unique id for layer identification.
         """
+        # Extract axes data first
+        axes_data = self._extract_axes_data()
+
+        # Extract and include format configuration inside axes if available.
+        format_config = self.extract_format(self.ax)
+        if format_config:
+            axes_data[MaidrKey.FORMAT] = format_config
+
         # Generate a unique UUID for this layer to ensure each plot layer can be distinctly identified
         # in the MAIDR frontend. This supports robust layer switching.
         maidr_schema = {
             MaidrKey.ID: str(uuid.uuid4()),
             MaidrKey.TYPE: self.type,
             MaidrKey.TITLE: self.ax.get_title(),
-            MaidrKey.AXES: self._extract_axes_data(),
+            MaidrKey.AXES: axes_data,
             MaidrKey.DATA: self._extract_plot_data(),
         }
 

maidr/core/plot/mplfinance_barplot.py

@@ -142,7 +142,11 @@ class MplfinanceBarPlot(
     def render(self) -> dict:
         base_schema = super().render()
         base_schema[MaidrKey.TITLE] = "Volume Bar Plot"
-        base_schema[MaidrKey.AXES] = self._extract_axes_data()
+        # Update axes labels while preserving format from parent
+        axes_data = self._extract_axes_data()
+        if MaidrKey.AXES in base_schema and MaidrKey.FORMAT in base_schema[MaidrKey.AXES]:
+            axes_data[MaidrKey.FORMAT] = base_schema[MaidrKey.AXES][MaidrKey.FORMAT]
+        base_schema[MaidrKey.AXES] = axes_data
         base_schema[MaidrKey.DATA] = self._extract_plot_data()
         if self._support_highlighting:
             base_schema[MaidrKey.SELECTOR] = self._get_selector()

maidr/core/plot/mplfinance_lineplot.py

@@ -192,7 +192,11 @@ class MplfinanceLinePlot(MaidrPlot, LineExtractorMixin):
     def render(self) -> dict:
         base_schema = super().render()
         base_schema[MaidrKey.TITLE] = "Moving Average Line Plot"
-        base_schema[MaidrKey.AXES] = self._extract_axes_data()
+        # Update axes labels while preserving format from parent
+        axes_data = self._extract_axes_data()
+        if MaidrKey.AXES in base_schema and MaidrKey.FORMAT in base_schema[MaidrKey.AXES]:
+            axes_data[MaidrKey.FORMAT] = base_schema[MaidrKey.AXES][MaidrKey.FORMAT]
+        base_schema[MaidrKey.AXES] = axes_data
         base_schema[MaidrKey.DATA] = self._extract_plot_data()
         if self._support_highlighting:
             base_schema[MaidrKey.SELECTOR] = self._get_selector()

maidr/util/datetime_conversion.py

@@ -49,14 +49,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__(
@@ -182,7 +182,7 @@ class DatetimeConverter:
         --------
         >>> 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" (plain datetime string)
         """
         if index not in self.date_mapping:
             return None
@@ -192,7 +192,7 @@ class DatetimeConverter:
 
     def _format_datetime_custom(self, dt: datetime) -> str:
         """
-        Consistent datetime formatting with year always included.
+        Return plain datetime string representation.
 
         Parameters
         ----------
@@ -202,24 +202,14 @@ class DatetimeConverter:
         Returns
         -------
         str
-            Formatted datetime string with consistent pattern.
+            Plain string representation of datetime (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 raw string representation of the datetime object,
+        allowing the frontend to handle formatting as needed.
         """
-        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 str(dt)
 
     @property
     def date_nums(self) -> List[float]: