maidr 1.3.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

maidr/util/mplfinance_utils.py

@@ -0,0 +1,409 @@
+"""
+Utility functions for handling mplfinance-specific data extraction and processing.
+"""
+
+import matplotlib.dates as mdates
+import numpy as np
+from matplotlib.patches import Rectangle
+from typing import List, Optional, Tuple, Any
+
+
+class MplfinanceDataExtractor:
+    """
+    Utility class for extracting and processing mplfinance-specific data.
+
+    This class handles the conversion of mplfinance plot elements (patches, collections)
+    into standardized data formats that can be used by the core plot classes.
+    """
+
+    @staticmethod
+    def extract_volume_data(
+        volume_patches: List[Rectangle], date_nums: Optional[List[float]] = None
+    ) -> List[dict]:
+        """
+        Extract volume data from mplfinance Rectangle patches.
+
+        Parameters
+        ----------
+        volume_patches : List[Rectangle]
+            List of Rectangle patches representing volume bars
+        date_nums : Optional[List[float]], default=None
+            List of matplotlib date numbers corresponding to the patches
+
+        Returns
+        -------
+        List[dict]
+            List of dictionaries with 'x' and 'y' keys for volume data
+        """
+        if not volume_patches:
+            return []
+
+        formatted_data = []
+
+        # Sort patches by x-coordinate to maintain order
+        sorted_patches = sorted(volume_patches, key=lambda p: p.get_x())
+
+        for i, patch in enumerate(sorted_patches):
+            height = patch.get_height()
+
+            # Use date mapping if available, otherwise use index
+            if date_nums is not None and i < len(date_nums):
+                date_num = date_nums[i]
+                x_label = MplfinanceDataExtractor._convert_date_num_to_string(date_num)
+            else:
+                x_label = f"date_{i:03d}"
+
+            formatted_data.append({"x": str(x_label), "y": float(height)})
+
+        return formatted_data
+
+    @staticmethod
+    def extract_candlestick_data(
+        body_collection: Any,
+        wick_collection: Any,
+        date_nums: Optional[List[float]] = 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
+
+        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()
+        face_colors = body_collection.get_facecolor()
+
+        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 based on color
+                is_up = MplfinanceDataExtractor._is_up_candle(face_colors, i)
+
+                # 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
+    ) -> 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
+
+        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()
+            face_color = rect.get_facecolor()
+
+            # Determine if this is an up or down candle based on color
+            is_up_candle = MplfinanceDataExtractor._is_up_candle_from_color(face_color)
+
+            # 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 clean_axis_label(label: str) -> str:
+        """
+        Clean up axis labels by removing LaTeX formatting.
+
+        Parameters
+        ----------
+        label : str
+            The original axis label
+
+        Returns
+        -------
+        str
+            Cleaned axis label
+        """
+        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
+
+    @staticmethod
+    def _convert_date_num_to_string(date_num: float) -> str:
+        """
+        Convert matplotlib date number to date string.
+
+        Parameters
+        ----------
+        date_num : float
+            Matplotlib date number
+
+        Returns
+        -------
+        str
+            Date string in YYYY-MM-DD format or fallback index
+        """
+        try:
+            # Check if this looks like a matplotlib date number (typically > 700000)
+            if date_num > 700000:
+                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")
+            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")
+                except:
+                    pass
+        except (ValueError, TypeError, OverflowError):
+            pass
+
+        # 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 _is_up_candle(face_colors: Any, index: int) -> bool:
+        """
+        Determine if a candle is up based on face color.
+
+        Parameters
+        ----------
+        face_colors : Any
+            Face colors from the collection
+        index : int
+            Index of the candle
+
+        Returns
+        -------
+        bool
+            True if up candle, False if down candle
+        """
+        is_up = True  # Default to up candle
+        if hasattr(face_colors, "__len__") and len(face_colors) > index:
+            color = (
+                face_colors[index]
+                if hasattr(face_colors[index], "__len__")
+                else face_colors
+            )
+            if isinstance(color, (list, tuple, np.ndarray)):
+                if len(color) >= 3:
+                    # Dark colors typically indicate down candles
+                    if color[0] < 0.5 and color[1] < 0.5 and color[2] < 0.5:
+                        is_up = False
+        return is_up
+
+    @staticmethod
+    def _is_up_candle_from_color(face_color: Any) -> bool:
+        """
+        Determine if a candle is up based on face color (for Rectangle patches).
+
+        Parameters
+        ----------
+        face_color : Any
+            Face color of the rectangle
+
+        Returns
+        -------
+        bool
+            True if up candle, False if down candle
+        """
+        try:
+            if (
+                isinstance(face_color, (list, tuple, np.ndarray))
+                and len(face_color) >= 3
+            ):
+                # Green colors typically indicate up candles
+                if face_color[1] > face_color[0]:
+                    return True
+                else:
+                    return False
+        except (TypeError, IndexError):
+            pass
+        return True  # Default to up candle
+
+    @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/util/plot_detection.py

@@ -0,0 +1,136 @@
+"""
+Utility functions for detecting plot types and determining appropriate plot classes.
+"""
+
+from matplotlib.axes import Axes
+from matplotlib.lines import Line2D
+from typing import Dict, Any, List, Union
+
+
+class PlotDetectionUtils:
+    """
+    Utility class for detecting plot characteristics and determining appropriate plot classes.
+    """
+
+    @staticmethod
+    def is_mplfinance_bar_plot(**kwargs) -> bool:
+        """
+        Detect if this is an mplfinance bar plot based on kwargs.
+
+        Parameters
+        ----------
+        **kwargs : dict
+            Keyword arguments passed to the plot factory
+
+        Returns
+        -------
+        bool
+            True if this is an mplfinance bar plot
+        """
+        return "_maidr_patches" in kwargs or "_maidr_date_nums" in kwargs
+
+    @staticmethod
+    def is_mplfinance_line_plot(ax: Axes, **kwargs) -> bool:
+        """
+        Detect if this is an mplfinance line plot based on kwargs or Line2D attributes.
+
+        Parameters
+        ----------
+        ax : Axes
+            The matplotlib axes object
+        **kwargs : dict
+            Keyword arguments passed to the plot factory
+
+        Returns
+        -------
+        bool
+            True if this is an mplfinance line plot
+        """
+        # Check kwargs first (more efficient)
+        if "_maidr_date_nums" in kwargs:
+            return True
+
+        # Check Line2D objects for mplfinance attributes
+        try:
+            for line in ax.get_lines():
+                if isinstance(line, Line2D) and hasattr(line, "_maidr_date_nums"):
+                    return True
+        except (AttributeError, TypeError):
+            # Handle cases where ax doesn't have get_lines() method (e.g., Mock objects)
+            pass
+
+        return False
+
+    @staticmethod
+    def is_mplfinance_candlestick_plot(**kwargs) -> bool:
+        """
+        Detect if this is an mplfinance candlestick plot based on kwargs.
+
+        Parameters
+        ----------
+        **kwargs : dict
+            Keyword arguments passed to the plot factory
+
+        Returns
+        -------
+        bool
+            True if this is an mplfinance candlestick plot
+        """
+        return any(key.startswith("_maidr_") for key in kwargs.keys())
+
+    @staticmethod
+    def should_use_candlestick_plot(
+        ax: Union[Axes, List[Axes], List[List[Axes]]], **kwargs
+    ) -> bool:
+        """
+        Determine if a candlestick plot should be used based on axes structure.
+
+        Parameters
+        ----------
+        ax : Union[Axes, List[Axes], List[List[Axes]]]
+            The matplotlib axes object(s)
+        **kwargs : dict
+            Keyword arguments passed to the plot factory
+
+        Returns
+        -------
+        bool
+            True if candlestick plot should be used
+        """
+        # Check if we have mplfinance-specific kwargs
+        if PlotDetectionUtils.is_mplfinance_candlestick_plot(**kwargs):
+            return True
+
+        # Check if we have a list of axes (typical for candlestick plots)
+        if isinstance(ax, list):
+            return True
+
+        return False
+
+    @staticmethod
+    def get_candlestick_axes(
+        ax: Union[Axes, List[Axes], List[List[Axes]]]
+    ) -> List[Axes]:
+        """
+        Extract and normalize axes for candlestick plots.
+
+        Parameters
+        ----------
+        ax : Union[Axes, List[Axes], List[List[Axes]]]
+            The matplotlib axes object(s)
+
+        Returns
+        -------
+        List[Axes]
+            Normalized list of axes for candlestick plotting
+        """
+        if isinstance(ax, list):
+            if ax and isinstance(ax[0], list):
+                # Handle nested list case: [[ax1, ax2]]
+                return ax[0]
+            else:
+                # Handle simple list case: [ax1, ax2]
+                return ax
+        else:
+            # Handle single axis case
+            return [ax]

{maidr-1.3.0.dist-info → maidr-1.4.1.dist-info}/METADATA

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

{maidr-1.3.0.dist-info → maidr-1.4.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-maidr/__init__.py,sha256=q3J6Xlb_5wM0iRIYZnMkvD0ValcEFxltt6-kbGrRKR4,399
+maidr/__init__.py,sha256=rjIWNGJRb5ksabBvZv4Ia2vq3YIhfCUr2sytbDXnV4U,415
 maidr/api.py,sha256=F43mXWsxc7tHdlZqbRlEWkc-RjJVo_zgxCn3NiLBY58,1764
 maidr/core/__init__.py,sha256=WgxLpSEYMc4k3OyEOf1shOxfEq0ASzppEIZYmE91ThQ,25
 maidr/core/context_manager.py,sha256=6cT7ZGOApSpC-SLD2XZWWU_H08i-nfv-JUlzXOtvWYw,3374
@@ -8,22 +8,24 @@ maidr/core/enum/maidr_key.py,sha256=ljG0omqzd8K8Yk213N7i7PXGvG-IOlnE5v7o6RoGJzc,
 maidr/core/enum/plot_type.py,sha256=7Orx3b_0NdpI_PtVJfLyJPh4qBqYMTsYBBr8VwOtiAM,347
 maidr/core/enum/smooth_keywords.py,sha256=VlpIX1BaoX8efwIrT72GIptxguTpiPtJvvJUPMoaFSQ,194
 maidr/core/figure_manager.py,sha256=jXs-Prkeru1Pahj21hjh8BAwXM9ZFUZ3GFfKUfIRX_M,4117
-maidr/core/maidr.py,sha256=kpN5axfJnWyaqXvyA1maioPOFh1rqod3XIvhIefcjOs,14225
+maidr/core/maidr.py,sha256=dxoJsvFyqhyv7PFHsYZrGAVnNmyjW0v0eng45cxhrf4,16325
 maidr/core/plot/__init__.py,sha256=xDIpRGM-4DfaSSL3nKcXrjdMecCHJ6en4K4nA_fPefQ,83
 maidr/core/plot/barplot.py,sha256=1HfoqyDGKIXkYQnCHN83Ye_faKpNQ3R4wjlbjD5jUyk,2092
 maidr/core/plot/boxplot.py,sha256=i11GdNuz_c-hilmhydu3ah-bzyVdFoBkNvRi5lpMrrY,9946
-maidr/core/plot/candlestick.py,sha256=8YKjNmxJx7TEvaH5v4lYDzA11VHpVHpZrv9EJG2Ter4,10587
+maidr/core/plot/candlestick.py,sha256=2eLdvZJSIgv9fW918uTn7ROsEGui7H3YaVGGFtqkBIw,5269
 maidr/core/plot/grouped_barplot.py,sha256=bRcQcvwkF3Q3aZ3PlhbZ6bHI_AfcqdKUMVvlLL94wXM,2078
 maidr/core/plot/heatmap.py,sha256=yMS-31tS2GW4peds9LtZesMxmmTV_YfqYO5M_t5KasQ,2521
 maidr/core/plot/histogram.py,sha256=QV5W-6ZJQQcZsrM91JJBX-ONktJzH7yg_et5_bBPfQQ,1525
 maidr/core/plot/lineplot.py,sha256=C3xz6uWXYM_mbTq_geb5bP0JdvhcQf6cpfTs78Y6fCM,3852
-maidr/core/plot/maidr_plot.py,sha256=B6hjsu-jSWlevEqJawgwjMOJr51nBBNh7yqJdSTkNhw,3681
-maidr/core/plot/maidr_plot_factory.py,sha256=5SC8Nc3IfVYn-jQU_SD9vw7R5yhTHTBgQwGnAc7_DmA,2507
+maidr/core/plot/maidr_plot.py,sha256=DN4TTRNt_SCqGa_mbkHrnpCk-eUQm71HoFRqs3bB6xk,3868
+maidr/core/plot/maidr_plot_factory.py,sha256=NW2iFScswgXbAC9rAOo4iMkAFsjY43DAvFioGr0yzx4,2732
+maidr/core/plot/mplfinance_barplot.py,sha256=feQlVMGA987EvgFii3V5vH74xGtBMBZhNlulU97vQL8,5184
+maidr/core/plot/mplfinance_lineplot.py,sha256=SVN81tau_IAsj17NZT-UtUEJ8NKBy-WxD1PznZELKHc,9338
 maidr/core/plot/regplot.py,sha256=b7u6bGTz1IxKahplNUrfwIr_OGSwMJ2BuLgFAVjL0s0,2744
 maidr/core/plot/scatterplot.py,sha256=o0i0uS-wXK9ZrENxneoHbh3-u-2goRONp19Yu9QLsaY,1257
 maidr/exception/__init__.py,sha256=PzaXoYBhyZxMDcJkuxJugDx7jZeseI0El6LpxIwXyG4,46
 maidr/exception/extraction_error.py,sha256=rd37Oxa9gn2OWFWt9AOH5fv0hNd3sAWGvpDMFBuJY2I,607
-maidr/patch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maidr/patch/__init__.py,sha256=FnkoUQJC2ODhLO37GwgRVSitBCRax42Ti0e4NIAgdO0,236
 maidr/patch/barplot.py,sha256=nxgBWBMUyf3eAW56CN5EKYYy3vsTgEPRlcvNYS3-WiU,2479
 maidr/patch/boxplot.py,sha256=l7wDD4pDi4ZbsL5EX5XDhPRxgtSIFSrFguMOZ7IC2eg,2845
 maidr/patch/candlestick.py,sha256=NFkzwpxmLBpWmb5s05pjk6obNMQee-xIEZTqGkbhhqM,1776
@@ -34,19 +36,22 @@ maidr/patch/highlight.py,sha256=I1dGFHJAnVd0AHVnMJzk_TE8BC8Uv-I6fTzSrJLU5QM,1155
 maidr/patch/histogram.py,sha256=k3N0RUf1SQ2402pwbaY5QyS98KnLWvr9glCHQw9NTko,2378
 maidr/patch/kdeplot.py,sha256=qv-OKzuop2aTrkZgUe2OnLxvV-KMyeXt1Td0_uZeHzE,2338
 maidr/patch/lineplot.py,sha256=og42V0tWBKCnf6idT3pLsIj3QBvKjg8aUN-k1udPRVw,1901
+maidr/patch/mplfinance.py,sha256=oxRhtKWnC-Fr9EBNS1RF-nKJKCKOPbtg4mseLsP1kMI,7967
 maidr/patch/regplot.py,sha256=Ciz43C5XZfWK6wtVWrlV0WNz4R__rcgdqVE9OCaXXRk,3236
 maidr/patch/scatterplot.py,sha256=kln6zZwjVsdQzICalo-RnBOJrx1BnIB2xYUwItHvSNY,525
-maidr/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maidr/util/__init__.py,sha256=eRJZfRpDX-n7UoV3JXw_9Lbfu_qNl_D0W1UTvLL-Iv4,81
 maidr/util/dedup_utils.py,sha256=RpgPL5p-3oULUHaTCZJaQKhPHfyPkvBLHMt8lAGpJ5A,438
 maidr/util/environment.py,sha256=-2LyZUpHojBCMEbkr_xkcC-_IDqtGDALB8683v7kTdI,5253
 maidr/util/mixin/__init__.py,sha256=aGJZNhtWh77yIVPc7ipIZm1OajigjMtCWYKPuDWTC-c,217
 maidr/util/mixin/extractor_mixin.py,sha256=oHtwpmS5kARvaLrSO3DKTPQxyFUw9nOcKN7rzTj1q4g,5192
 maidr/util/mixin/merger_mixin.py,sha256=V0qLw_6DUB7X6CQ3BCMpsCQX_ZuwAhoSTm_E4xAJFKM,712
+maidr/util/mplfinance_utils.py,sha256=AvDzvAAQbMsPZxcxWr3DwctZMp4xW5CkQEBezWTk1mY,13704
+maidr/util/plot_detection.py,sha256=bVSocZMGCLP6CduRSpOmwIzLFWEBnNdYN9T1ULfVPMw,3893
 maidr/util/regression_line_utils.py,sha256=P8RQLixTby2JLz73XZgNiu96C2Ct3pNe4ENRWOjgT8M,509
 maidr/util/svg_utils.py,sha256=2gyzBtNKFHs0utrw1iOlxTmznzivOWQMV2aW8zu2c8E,1442
 maidr/widget/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maidr/widget/shiny.py,sha256=wrrw2KAIpE_A6CNQGBtNHauR1DjenA_n47qlFXX9_rk,745
-maidr-1.3.0.dist-info/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-maidr-1.3.0.dist-info/METADATA,sha256=m0inXLNCctWjHu0KGU-tQd7q459C2xskdw3LC8-KTsw,2664
-maidr-1.3.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-maidr-1.3.0.dist-info/RECORD,,
+maidr-1.4.1.dist-info/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+maidr-1.4.1.dist-info/METADATA,sha256=rGSOkUIcGPVk2z2SgpfMy1EP_B7m0HgpStq3h1SKdK4,2664
+maidr-1.4.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+maidr-1.4.1.dist-info/RECORD,,