Dash_tooltip 0.5.0__py3-none-any.whl

dash_tooltip/__init__.py

@@ -0,0 +1,267 @@
+import logging
+import re
+from string import Template
+from typing import Any, Dict, List, Optional, Union
+
+import plotly.graph_objs as go
+from dash import Input, Output, State, dash
+from dash.exceptions import PreventUpdate
+
+from .config import DEFAULT_ANNOTATION_CONFIG, DEFAULT_TEMPLATE
+from .custom_figure import CustomFigure
+from .utils import _display_click_data, _find_all_graph_ids, add_annotation_store
+
+# Logger setup
+logger = logging.getLogger("dash_tooltip")
+logger.setLevel(logging.DEBUG)
+
+# File handler setup
+file_handler = logging.FileHandler("dash_app.log")
+file_handler.setLevel(logging.DEBUG)
+
+# Create a formatter and add it to the handler
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+file_handler.setFormatter(formatter)
+
+# Add the handler to the logger
+logger.addHandler(file_handler)
+
+# Prevent logs from being propagated to the root logger
+logger.propagate = False
+
+# Now, you can log messages
+logger.debug("dash_tooltip log active")
+
+registered_callbacks = set()
+ANNOTATION_RELAYOUT_KEY = re.compile(r"annotations\[(\d+)\]\.(.+)")
+
+
+def _apply_annotation_relayout(
+    current_figure: Dict[str, Any], relayout_data: Dict[str, Any]
+) -> bool:
+    """Persist client-side annotation edits back into the server-side figure."""
+    if not relayout_data:
+        return False
+
+    annotation_updates: Dict[int, Dict[str, Any]] = {}
+    for key, value in relayout_data.items():
+        match = ANNOTATION_RELAYOUT_KEY.fullmatch(key)
+        if not match:
+            continue
+
+        index = int(match.group(1))
+        property_name = match.group(2)
+        annotation_updates.setdefault(index, {})[property_name] = value
+
+    if not annotation_updates:
+        return False
+
+    layout = current_figure.get("layout")
+    if not isinstance(layout, dict):
+        return False
+
+    annotations = layout.get("annotations", [])
+    if not isinstance(annotations, list) or not annotations:
+        return False
+
+    changed = False
+    for index, properties in annotation_updates.items():
+        if index >= len(annotations):
+            continue
+        annotation = annotations[index]
+        if not isinstance(annotation, dict):
+            annotation = dict(annotation)
+        annotation.update(properties)
+        annotations[index] = annotation
+        changed = True
+
+    if changed:
+        layout["annotations"] = annotations
+    return changed
+
+
+class TooltipManager:
+    def __init__(
+        self,
+        app: dash.Dash,
+        style: Dict[Any, Any],
+        template: str,
+        graph_ids: List[str],
+        apply_log_fix: bool,
+        debug: bool,
+    ):
+        self.figures = {graph_id: CustomFigure() for graph_id in graph_ids}
+        self.templates = {graph_id: template for graph_id in graph_ids}
+        self.style = style
+        self.apply_log_fix = apply_log_fix
+        self.debug = debug
+        self.app = app
+        self.graph_ids = graph_ids
+        self.tooltip_active = True  # Default to active
+        self.initialize_callbacks()
+
+    def update_template(self, graph_id: str, template: str):
+        if graph_id in self.figures:
+            self.templates[graph_id] = template
+            self.figures[graph_id].update_template(template)
+
+    def initialize_callbacks(self):
+        for graph_id in self.graph_ids:
+            callback_identifier = (graph_id, "figure")
+            if callback_identifier in registered_callbacks:
+                # Skip reattaching if already registered
+                continue
+            registered_callbacks.add(callback_identifier)
+
+            # Check for valid graph ID and add annotation store
+            if graph_id not in self.app.layout:
+                raise ValueError(f"Invalid graph ID provided: {graph_id}")
+            add_annotation_store(self.app.layout, graph_id)
+
+            @self.app.callback(
+                Output(component_id=graph_id, component_property="figure"),
+                Input(component_id=graph_id, component_property="clickData"),
+                State(component_id=graph_id, component_property="figure"),
+            )
+            def display_click_data(
+                clickData: Dict[str, Any],
+                figure: Union[CustomFigure, Dict[str, Any]],
+            ) -> CustomFigure:
+                """Display data on click event."""
+                if not self.tooltip_active:
+                    raise PreventUpdate
+
+                if figure is None:
+                    figure = CustomFigure()
+
+                template = self.templates[graph_id]
+                if isinstance(figure, CustomFigure):
+                    return _display_click_data(clickData, figure, template, self.style)
+                # Check if figure is a dictionary
+                elif isinstance(figure, dict):
+                    # Extract data and layout from the figure dictionary
+                    raw_data = figure.get("data", [])
+                    layout = figure.get("layout", {})
+
+                    # Convert dictionary representations of traces into actual trace objects
+                    data = []
+                    for trace in raw_data:
+                        trace_type = trace.pop("type")
+                        trace_class = getattr(go, trace_type.capitalize())
+                        data.append(trace_class(**trace))
+
+                    # Construct the CustomFigure(go.Figure) using data and layout
+                    custom_figure = CustomFigure(data=data, layout=layout)
+                    return _display_click_data(
+                        clickData, custom_figure, template, self.style
+                    )
+                else:
+                    custom_figure = CustomFigure(figure)
+                    return _display_click_data(
+                        clickData, custom_figure, template, self.style
+                    )
+
+            @self.app.callback(
+                Output(graph_id, "figure", allow_duplicate=True),
+                Input(graph_id, "relayoutData"),
+                State(graph_id, "figure"),
+                prevent_initial_call=True,
+            )
+            def persist_annotation_relayout(
+                relayout_data: Dict[str, Any], current_figure: Dict[str, Any]
+            ) -> Union[Dict[str, Any], dash._callback.NoUpdate]:
+                """Persist dragged or edited annotation properties."""
+                if current_figure and _apply_annotation_relayout(
+                    current_figure, relayout_data
+                ):
+                    return current_figure
+                return dash.no_update
+
+            @self.app.callback(
+                Output(graph_id, "figure", allow_duplicate=True),
+                Input(f"tooltip-annotations-to-remove-{graph_id}", "data"),
+                State(graph_id, "figure"),
+                prevent_initial_call=True,
+            )
+            def remove_empty_annotations(
+                indices_to_remove: List[int], current_figure: Dict[str, Any]
+            ) -> Union[Dict[str, Any], dash._callback.NoUpdate]:
+                """Remove annotations that have been deleted by the user."""
+                if indices_to_remove:
+                    annotations = current_figure["layout"].get("annotations", [])
+                    logger.debug(f"Original Annotations: {annotations}")
+                    updated_annotations = [
+                        anno
+                        for idx, anno in enumerate(annotations)
+                        if idx not in indices_to_remove
+                    ]
+                    logger.debug(f"Indices to Remove: {indices_to_remove}")
+                    logger.debug(f"Updated Annotations: {updated_annotations}")
+                    current_figure["layout"]["annotations"] = updated_annotations
+                    return current_figure
+                return dash.no_update
+
+            # Client-side callback to identify annotations to remove
+            dbg_str = "console.log(relayoutData);" if self.debug else ""
+            self.app.clientside_callback(
+                Template(
+                    """
+                    function(relayoutData) {
+                        $dbg_str
+                        var annotationPattern = /annotations\\[(\\d+)\\].text/;
+                        var indicesToRemove = [];
+                        for (var key in relayoutData) {
+                            var match = key.match(annotationPattern);
+                            if (match && relayoutData[key] === "") {
+                                indicesToRemove.push(parseInt(match[1]));
+                            }
+                        }
+                        return indicesToRemove;
+                    }
+                    """
+                ).substitute(dbg_str=dbg_str),
+                Output(f"tooltip-annotations-to-remove-{graph_id}", "data"),
+                Input(graph_id, "relayoutData"),
+            )
+
+
+def tooltip(
+    app: dash.Dash,
+    style: Dict[Any, Any] = DEFAULT_ANNOTATION_CONFIG,
+    template: str = DEFAULT_TEMPLATE,
+    graph_ids: Optional[List[str]] = None,
+    apply_log_fix: bool = True,
+    debug: bool = False,
+) -> TooltipManager:
+    """
+    Add tooltip functionality to Dash graph components.
+
+    Args:
+        app (dash.Dash): The Dash app instance.
+        style (dict): Configuration for the tooltip appearance.
+                      Users can provide any valid Plotly annotation style options.
+        template (str): The default annotation template.
+                        Default is a basic string template.
+        graph_ids (list, optional): List of graph IDs to apply tooltips to.
+                                    If not provided, will try to auto-detect from the layout.
+        apply_log_fix (bool): If True, applies a fix for logging issues.
+        debug (bool): If True, enables debugging mode.
+
+    Returns:
+        TooltipManager: An instance of TooltipManager class.
+    """
+    if graph_ids is None:
+        graph_ids = _find_all_graph_ids(app.layout)
+        if not graph_ids:
+            raise ValueError(
+                "No graphs found in the app layout. Please provide a graph ID."
+            )
+    return TooltipManager(app, style, template, graph_ids, apply_log_fix, debug)
+
+
+__all__ = [
+    "tooltip",
+    "add_annotation_store",
+    "DEFAULT_ANNOTATION_CONFIG",
+    "DEFAULT_TEMPLATE",
+]

dash_tooltip/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.4.3.dev0+gc0d76c5.d20250329'
+__version_tuple__ = version_tuple = (0, 4, 3, 'dev0', 'gc0d76c5.d20250329')

dash_tooltip/config.py

@@ -0,0 +1,18 @@
+DEFAULT_ANNOTATION_CONFIG = {
+    # horizontal alignment of the text (can be 'left', 'center', or 'right')
+    "align": "left",
+    "arrowcolor": "black",  # color of the annotation arrow
+    "arrowhead": 3,  # type of arrowhead, for Plotly (an integer from 0 to 8)
+    "arrowsize": 1.8,  # relative size of the arrowhead to the arrow stem, for Plotly
+    "arrowwidth": 1,  # width of the annotation arrow in pixels, for Plotly
+    "font": {
+        "color": "black",  # color of the annotation text
+        "family": "Arial",  # font family of the annotation text, for Plotly
+        "size": 12,  # size of the annotation text in points, for Plotly
+    },
+    "showarrow": True,
+    # horizontal alignment of the text (can be 'left', 'center', or 'right')
+    "xanchor": "left",
+}
+
+DEFAULT_TEMPLATE = "x: %{x},<br>y: %{y}"

dash_tooltip/custom_figure.py

@@ -0,0 +1,12 @@
+import plotly.graph_objs as go
+
+from dash_tooltip import DEFAULT_TEMPLATE
+
+
+class CustomFigure(go.Figure):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._tooltip_template = DEFAULT_TEMPLATE
+
+    def update_template(self, template):
+        self.layout._tooltip_template = template

dash_tooltip/utils.py

@@ -0,0 +1,324 @@
+import json
+import logging
+import math
+import re
+from typing import Any, Dict, List, Optional, Union
+
+import dash
+import plotly.graph_objs as go
+from dash import dcc
+from dash.html import Div
+
+from .config import DEFAULT_ANNOTATION_CONFIG
+from .custom_figure import CustomFigure
+
+logger = logging.getLogger("dash_tooltip")
+
+
+def _normalize_annotation_value(value: Any) -> Any:
+    if isinstance(value, float):
+        return format(value, ".15g")
+    return str(value)
+
+
+def _annotation_exists(fig: CustomFigure, x: Any, y: Any, xref: str, yref: str) -> bool:
+    annotations = fig.layout.annotations or []
+    for annotation in annotations:
+        if (
+            _normalize_annotation_value(getattr(annotation, "x", None))
+            == _normalize_annotation_value(x)
+            and _normalize_annotation_value(getattr(annotation, "y", None))
+            == _normalize_annotation_value(y)
+            and getattr(annotation, "xref", None) == xref
+            and getattr(annotation, "yref", None) == yref
+        ):
+            return True
+    return False
+
+
+def add_annotation_store(layout: Div, graph_id: Optional[str] = None) -> str:
+    """
+    Adds a dcc.Store component to the layout to store annotations for tooltips.
+
+    Args:
+        layout (dash.html.Div): The Dash app layout.
+        graph_id (str, optional): The ID of the graph component to which the store is linked.
+
+    Returns:
+        str: The ID of the added dcc.Store component.
+    """
+    store_id = "tooltip-annotations-to-remove"
+    if graph_id:
+        store_id += f"-{graph_id}"
+
+    if not any(
+        isinstance(child, dcc.Store) and child.id == store_id
+        for child in layout.children
+    ):
+        if isinstance(layout.children, list):
+            layout.children.append(dcc.Store(id=store_id))
+
+    return store_id
+
+
+def _find_all_graph_ids(layout: Div) -> List[str]:
+    """Recursively search for all graph component IDs in the app layout."""
+    graph_ids = []
+
+    if isinstance(layout, dcc.Graph):
+        return [layout.id]
+
+    if hasattr(layout, "children"):
+        if isinstance(layout.children, list):
+            for child in layout.children:
+                graph_ids.extend(_find_all_graph_ids(child))
+        else:
+            graph_ids.extend(_find_all_graph_ids(layout.children))
+
+    return graph_ids
+
+
+def extract_value_from_point(point: Dict[str, Any], key: str) -> Any:
+    """Extracts the value from the point dictionary using a dot notation key."""
+    try:
+        parts = key.split(".")
+        temp: Any = point
+        for part in parts:
+            match = re.match(r"(\w+)\[(\d+)\]", part)
+            if match:
+                name, index = match.groups()
+                index = int(index)
+                if temp and isinstance(temp, dict) and name in temp:
+                    temp = temp.get(name, [])[index]
+                else:
+                    return None
+            else:
+                if temp and isinstance(temp, dict):
+                    temp = temp.get(part)
+                else:
+                    return None
+        return temp
+    except Exception as e:
+        logger.error(f"Error extracting value with key {key}. Error: {e}")
+        return None
+
+
+def truncate_json_arrays(json_str: str, limit: int) -> str:
+    """
+    Truncate arrays in a JSON string representation to a specified limit, both at top level and nested.
+
+    Parameters:
+        json_str (str): The JSON string representation to be processed.
+        limit (int): The maximum number of elements to keep in any array.
+
+    Returns:
+        str: The processed JSON string with arrays truncated.
+    """
+
+    def truncate_arrays(data: Any) -> Any:
+        """
+        Recursively truncate arrays in a data structure (dicts or lists).
+        """
+        if isinstance(data, list):
+            truncated_data = data[:limit]
+            if len(data) > limit:
+                truncated_data.append("[TRUNCATED]")
+            return [truncate_arrays(item) for item in truncated_data]
+        elif isinstance(data, dict):
+            return {key: truncate_arrays(value) for key, value in data.items()}
+        else:
+            return data
+
+    data = json.loads(json_str)
+    truncated_data = truncate_arrays(data)
+
+    return json.dumps(truncated_data, indent=4)
+
+
+def deep_merge_dicts(dict1: Dict[str, Any], dict2: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Recursively merges two dictionaries.
+    Nested keys from dict2 will overwrite those in dict1.
+    """
+    for key, value in dict2.items():
+        if isinstance(value, dict) and key in dict1 and isinstance(dict1[key], dict):
+            dict1[key] = deep_merge_dicts(dict1[key], value)
+        else:
+            dict1[key] = value
+    return dict1
+
+
+def get_axis_type(fig: go.Figure, axis: str) -> str:
+    """
+    Determines the type of the specified axis in a Plotly figure.
+
+    Parameters:
+        fig (go.Figure): The Plotly figure object.
+        axis (str): The axis identifier, e.g., 'x', 'y', 'x2', 'y2', etc.
+
+    Returns:
+        str: The type of the specified axis, e.g., 'linear' or 'log'.
+    """
+    # Check if the axis identifier has a number at the end
+    axis_number = axis[-1]
+    if axis_number.isnumeric():
+        axis_key = axis[:-1] + "axis" + axis_number
+    else:
+        axis_key = axis + "axis"
+
+    return fig.layout[axis_key].type
+
+
+def _display_click_data(
+    clickData: Dict[str, Any],
+    figure: Union[CustomFigure, Dict[str, Any]],  # Allow both go.Figure and dictionary
+    template: str,
+    config: Dict[Any, Any],
+    apply_log_fix: bool = True,
+    debug: bool = False,
+) -> CustomFigure:
+    """
+    Displays the tooltip on the graph when a data point is clicked.
+
+    Args:
+        clickData (Dict[str, Any]): The data from the click event.
+        figure (Union[CustomFigure, Dict[str, Any]]): The figure to update.
+        template (str): The template for the tooltip.
+        config (Dict[Any, Any]): The configuration for the tooltip.
+        apply_log_fix (bool, optional): Whether to apply the log axis fix. Defaults to True.
+        debug (bool, optional): Whether to enable debugging. Defaults to False.
+
+    Returns:
+        CustomFigure: The updated figure.
+    """
+    xaxis, yaxis = "x", "y"  # Default values
+
+    if figure is None:
+        raise ValueError("The figure provided is None.")
+
+    # Check if figure is a dictionary
+    if isinstance(figure, dict):
+        # Extract data and layout from the figure dictionary
+        raw_data = figure.get("data", [])
+        layout = figure.get("layout", {})
+
+        # Convert dictionary representations of traces into actual trace objects
+        data = []
+        for trace in raw_data:
+            trace_type = trace.pop("type")
+            trace_class = getattr(go, trace_type.capitalize())
+            data.append(trace_class(**trace))
+
+        # Construct the go.Figure using data and layout
+        fig = CustomFigure(data=data, layout=layout)
+    elif isinstance(figure, CustomFigure):
+        fig = figure
+    else:
+        raise TypeError(
+            "The figure provided must be of type 'CustomFigure' or a dictionary."
+        )
+
+    fig.update_template(template)
+
+    merged_config = deep_merge_dicts(DEFAULT_ANNOTATION_CONFIG.copy(), config)
+
+    if not dash.callback_context:
+        raise dash.exceptions.PreventUpdate
+
+    if clickData:
+        point = clickData["points"][0]
+        x_val = point["x"]
+        y_val = point["y"]
+
+        try:
+            # Extract the clicked axis information from the curve data
+            if "xaxis" in fig["data"][point["curveNumber"]]:
+                xaxis = fig["data"][point["curveNumber"]]["xaxis"]
+            else:
+                xaxis = "x"
+
+            if "yaxis" in fig["data"][point["curveNumber"]]:
+                yaxis = fig["data"][point["curveNumber"]]["yaxis"]
+            else:
+                yaxis = "y"
+
+            if "meta" in fig["data"][point["curveNumber"]]:
+                point["meta"] = fig["data"][point["curveNumber"]]["meta"]
+
+            if "name" in fig["data"][point["curveNumber"]]:
+                point["name"] = fig["data"][point["curveNumber"]]["name"]
+
+            # If the x-axis is logarithmic, adjust `x_val`
+            if apply_log_fix and get_axis_type(fig, xaxis) == "log":
+                x_val = math.log10(x_val)
+
+            # If the y-axis is logarithmic, adjust `y_val`
+            if apply_log_fix and get_axis_type(fig, yaxis) == "log":
+                y_val = math.log10(y_val)
+
+        except KeyError as e:
+            logger.error(f"Error: {e}, key not found")
+        except Exception as e:
+            logger.error(f"An unexpected error occurred: {e}")
+
+        if debug:
+            logger.debug(
+                f"clickData: {truncate_json_arrays(json.dumps(clickData, indent=4), 2)}"
+            )
+            logger.debug(
+                f"figure: {truncate_json_arrays(json.dumps(fig, indent=4), 2)}"
+            )
+            logger.debug(
+                "Point data:\n%s", truncate_json_arrays(json.dumps(point, indent=4), 2)
+            )
+            logger.debug(
+                "Trace data:\n%s",
+                truncate_json_arrays(
+                    json.dumps(fig["data"][point["curveNumber"]], indent=4), 2
+                ),
+            )
+
+        placeholders = re.findall(r"%{(.*?)}", fig.layout._tooltip_template)
+
+        template_data = {}
+        for placeholder in placeholders:
+            parts = placeholder.split(":")
+            var_name = parts[0]
+            format_spec = parts[1] if len(parts) > 1 else None
+
+            value = extract_value_from_point(point, var_name)
+            if value is not None:
+                if format_spec:
+                    try:
+                        # Applying the format specifier directly
+                        template_data[placeholder] = f"{value:{format_spec}}"
+                    except ValueError as e:
+                        logger.error(
+                            f"Error formatting value {value}, with format {format_spec}. Error: {e}"
+                        )
+                        template_data[placeholder] = str(value)
+                else:
+                    template_data[placeholder] = str(value)
+
+        tooltip_template = fig.layout._tooltip_template
+        for placeholder, value in template_data.items():
+            tooltip_template = tooltip_template.replace(f"%{{{placeholder}}}", value)
+
+        if _annotation_exists(fig, x_val, y_val, xaxis, yaxis):
+            return fig
+
+        try:
+            fig.add_annotation(
+                x=x_val,
+                y=y_val,
+                xref=xaxis,
+                yref=yaxis,
+                text=tooltip_template,
+                **merged_config,
+            )
+        except ValueError as e:
+            logger.error(
+                f"Failed to add annotation due to invalid properties in {merged_config}. Error: {e}"
+            )
+            raise e
+    return fig

dash_tooltip-0.5.0.dist-info/METADATA

@@ -0,0 +1,301 @@
+Metadata-Version: 2.4
+Name: Dash_tooltip
+Version: 0.5.0
+Summary: A tooltip functionality for Dash.
+Author: kb-
+Project-URL: Homepage, https://github.com/kb-/Dash_tooltip
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dash>=2.13.0
+Requires-Dist: plotly>=5.17.0
+Dynamic: license-file
+
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dash-tooltip)
+[![CodeQL](https://github.com/kb-/Dash_tooltip/actions/workflows/codeql.yml/badge.svg?branch=main)](https://github.com/kb-/Dash_tooltip/actions/workflows/codeql.yml)
+[![Downloads](https://static.pepy.tech/badge/dash_tooltip)](https://pepy.tech/project/dash_tooltip)
+[![Pytest](https://github.com/kb-/Dash_tooltip/actions/workflows/Pytest.yml/badge.svg)](https://github.com/kb-/Dash_tooltip/actions/workflows/Pytest.yml)
+
+# Dash Tooltip
+
+A module to add interactive editable tooltips to your Dash applications. Inspired by `mplcursors` and Matlab's `datatip`.
+
+![newplot(6)](https://github.com/kb-/Dash_tooltip/assets/2260417/0d62008c-25f2-4128-aa31-6746b6b82248)
+
+## Installation
+
+`pip install dash-tooltip`
+
+## Build And Publish
+
+With the current `pyproject.toml`-based setup, use `uv` for local builds and publishing:
+
+```bash
+# Build source distribution and wheel into dist/
+uv build
+
+# Install the built wheel locally
+uv pip install dist/*.whl
+
+# Publish to PyPI
+uv publish
+```
+
+## Basic Usage
+
+```python
+import numpy as np
+import plotly.express as px
+from dash import Dash, dcc, html
+from dash.dependencies import Input, Output
+from dash_tooltip import tooltip
+
+# Sample Data
+np.random.seed(20)
+y1 = np.random.normal(0, 10, 50)
+x1 = np.arange(0, 50)
+fig1 = px.scatter(x=x1, y=y1)
+fig1.update_layout(title_text="Editable Title", title_x=0.5)
+
+app1 = Dash(__name__)
+
+#makes graph items, including tooltips editable
+app1.layout = html.Div([
+    dcc.Graph(
+        id='graph1',
+        figure=fig1,
+        config={
+            'editable': True,
+            'edits': {
+                'shapePosition': True,
+                'annotationPosition': True
+            }
+        }
+    )
+])
+
+# Add the tooltip functionality to the app
+tooltip(app1)
+```
+Click on data points to add tooltips.
+If `dcc.Graph` is configured editatble, tolltips:
+- can be dragged around
+- text can be edited on click
+- can be deleted: click, delete text, enter. In some occasions a tooltip arrow may remain due to a Dash bug (clientside_callback not firing). In this cas, click near arrow end (mouse cursor changes to pointer), enter some text and repeat deletion and enter.
+
+
+## Advanced Usage
+
+If you want to customize the tooltips, hover templates, and more:
+
+```python
+import pandas as pd
+import numpy as np
+import plotly.express as px
+from dash import Dash, dcc, html
+from dash.dependencies import Input, Output
+from dash_tooltip import tooltip
+
+# Generate random time series data
+date_rng = pd.date_range(start='2020-01-01', end='2020-12-31', freq='h')
+ts1 = pd.Series(np.random.randn(len(date_rng)), index=date_rng, name='Time Series 1')
+ts2 = pd.Series(np.random.randn(len(date_rng)), index=date_rng, name='Time Series 2')
+df = pd.DataFrame({ts1.name: ts1, ts2.name: ts2})
+
+# Define the hover and tooltip template
+# name is only compatible with tooltip
+template = "name:%{name}<br>META0: %{meta[0]}<br>META1: %{meta[1]}<br>x: %{x}<br>y: %{y:.2f}<br>pointNumber: %{pointNumber}<br>customdata0: %{customdata[0]}<br>customdata1: %{customdata[1]}"
+
+# Create a line plot
+fig10 = px.line(df, x=df.index, y=df.columns, title="Time Series Plot")
+
+# Apply metadata and custom data to each trace
+for i, trace in enumerate(fig10.data):
+    # Applying different metadata to each trace
+    trace.meta = [f"META{i}0", f"META{i}1"]
+    
+    # Setting customdata for each point in the trace, for use in the hover template
+    trace.customdata = np.array([[f"Series {i+1}", f'Point {j+1}'] for j in range(len(df))])
+    
+    # Setting the hover template
+    trace.hovertemplate = template
+
+app10 = Dash(__name__)
+
+app10.layout = html.Div([
+    dcc.Graph(
+        id="graph-id",
+        figure=fig10,
+        config={
+            'editable': True,
+            'edits': {
+                'shapePosition': True,
+                'annotationPosition': True
+            }
+        }
+    )
+])
+
+tooltip(app10, graph_ids=["graph-id"], template=template, debug=True)
+app10.run(port=8082)
+```
+
+## Tooltip Templates with Formatting
+
+Tooltips can be formatted using templates similar to Plotly's hovertemplates. The tooltip template allows custom formatting and the inclusion of text and values.
+
+For example, you can use a template like `"%{name}<br>%{meta[0]}<br>x: %{x:.2f}<br>y: %{y:.2f}"` to display the track `name`, `meta[0]` from a list of text data, plus `x` and `y` values with two decimal places. Note that `name` key is not available in the Plotly hover template, but is displayed by default.
+
+Refer to [Plotly’s documentation on hover text and formatting](https://plotly.com/python/hover-text-and-formatting/) for more details on how to construct and customize your tooltip templates.
+
+## Custom Styling
+
+```python
+custom_style = {
+        "font": {"size": 12, "color":"red"},
+        "arrowcolor": "red",
+        'arrowsize': 5,
+        # ... any other customization
+    }
+tooltip(app10, style=custom_style, graph_ids=["graph-id"], template=template, debug=True)
+```
+
+For more examples, refer to the provided `dash_tooltip_demo.py` and check out [Plotly’s Text and Annotations documentation](https://plotly.com/python/text-and-annotations/#styling-and-coloring-annotations), which provides a wealth of information on customizing the appearance of annotations.
+Refer to the [Plotly Annotation Reference](https://plotly.com/python/reference/layout/annotations/) for a comprehensive guide on available styling attributes and how to apply them.
+
+## Template updating
+
+Tooltip content can be updated to match with selected data in a dynamic Dash app:
+```python
+GRAPH_ID = "scatter-plot16a"
+
+# Sample DataFrame with DatetimeIndex
+date_range = pd.date_range(start="2025-01-01", periods=5)
+df = pd.DataFrame(
+    {
+        "x": [1, 2, 3, 4, 5],
+        "y": [2, 4, 6, 8, 10],
+        "z": [3, 6, 9, 12, 15],
+        "a": [4, 8, 12, 16, 20],
+        "b": [5, 10, 15, 20, 25],
+    },
+    index=date_range,
+)
+
+# Initialize the Dash app
+app16 = dash.Dash(__name__)
+
+# Define the layout
+app16.layout = html.Div(
+    [
+        html.Label("Select X and Y columns:"),
+        dcc.Dropdown(
+            id="x-column",
+            options=[{"label": col, "value": col} for col in df.columns],
+            placeholder="Select X axis data",
+        ),
+        dcc.Dropdown(
+            id="y-column",
+            options=[{"label": col, "value": col} for col in df.columns],
+            placeholder="Select Y axis data",
+        ),
+        dcc.Graph(
+            id=GRAPH_ID,
+            style={"width": "600px", "height": "600px"},
+            config={
+                "editable": True,
+                "edits": {"shapePosition": True, "annotationPosition": True},
+            },
+        ),
+    ]
+)
+
+# Create a tooltip instance
+tooltip_instance16 = tooltip(app16, graph_ids=[GRAPH_ID])
+
+# Define callback to update the scatter plot
+@app16.callback(
+    Output(GRAPH_ID, "figure", allow_duplicate=True),
+    [Input("x-column", "value"), Input("y-column", "value")],
+    prevent_initial_call=True,
+)
+def update_scatter_plot(x_column, y_column):
+    if not x_column or not y_column:
+        raise PreventUpdate  # Prevent update if either dropdown is not selected
+
+    non_selected_columns = [
+        col for col in df.columns if col not in [x_column, y_column]
+    ]
+    customdata = df[non_selected_columns].apply(
+        lambda row: "<br>".join(
+            f"{col}: {val}" for col, val in zip(non_selected_columns, row)
+        ),
+        axis=1,
+    )
+    # gives (depending on selected entries):
+    # 2022-01-01     x: 1<br>z: 3<br>b: 5
+    # 2022-01-02     x: 2<br>z: 6<br>b: 10
+    # ...
+
+    # New template, to match selected data entries
+    template = (
+        "<b>Date</b>: %{customdata}<br>"
+        + f"<b>{x_column}: %{{x}}<br>"
+        + f"{y_column}: %{{y}}</b><br>"
+    )
+    # gives (depending on selected entries):
+    # <b>Date</b>: %{customdata}<br><b>x: %{x}<br><b>a</b>: %{y}<br>
+
+    # Update template for new tooltips
+    tooltip_instance16.update_template(graph_id=GRAPH_ID, template=template)
+
+    trace = go.Scatter(
+        x=df[x_column],
+        y=df[y_column],
+        mode="markers",
+        marker=dict(color="blue"),
+        customdata=df.index.strftime("%Y-%m-%d %H:%M:%S") + "<br>" + customdata,
+        # Include date and time with other data
+        hovertemplate=template,
+    )
+    layout = go.Layout(
+        title="Scatter Plot",
+        xaxis=dict(title=x_column),
+        yaxis=dict(title=y_column),
+        hovermode="closest",
+        height=800,
+        width=800,
+    )
+    return {"data": [trace], "layout": layout}
+
+
+# Run the app
+if __name__ == "__main__":
+app16.run(debug=False, port=8196)
+```
+
+## Handling Log Axes
+
+Due to a long-standing bug in Plotly (see [Plotly Issue #2580](https://github.com/plotly/plotly.py/issues/2580)), annotations (`fig.add_annotation`) may not be placed correctly on log-scaled axes. The `dash_tooltip` module provides an option to automatically correct the tooltip placement on log-scaled axes via the `apply_log_fix` argument in the `tooltip` function. By default, `apply_log_fix` is set to `True` to enable the fix.
+
+## Debugging
+
+If you encounter any issues or unexpected behaviors, enable the debug mode by setting the `debug` argument of the `tooltip` function to `True`. The log outputs will be written to `dash_app.log` in the directory where your script or application is located.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Acknowledgements
+
+- Inspired by `mplcursors` and Matlab's `datatip`.

dash_tooltip-0.5.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+dash_tooltip/__init__.py,sha256=lMISp--speJuMSqwxttnjPrQl3NSAqifKqkRF0WUMB4,10298
+dash_tooltip/_version.py,sha256=VgJxLFMR_D2Bdx1B0gV0fBHBM-yHMFQUDPjx3w1PU_M,586
+dash_tooltip/config.py,sha256=FEGpY4bxCSCv_8HSIyPl0BrMpUvxrxNLTXmAu25rV2c,842
+dash_tooltip/custom_figure.py,sha256=a8hWSYnLs66VX6i8FyKqWKvcHD6a75vihcG_w1BJwBE,343
+dash_tooltip/utils.py,sha256=BnrOJ0_naXmuUKEVzoTRHrPqm7bbw1kpyZ59AbXKE5U,11262
+dash_tooltip-0.5.0.dist-info/licenses/LICENSE,sha256=iprCc-jRiuJNs3MnFMOct-tWW_D5bBG1RASo-wQNTQk,1081
+dash_tooltip-0.5.0.dist-info/METADATA,sha256=7NvNM6uXpyN25BE3gZbga5xLVgYO7FMPQTUnBfCHxMA,10717
+dash_tooltip-0.5.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+dash_tooltip-0.5.0.dist-info/top_level.txt,sha256=W8gDLeFCRYy1nSEeg_k2AwGM8Zm2vi28QkWZlVpinck,13
+dash_tooltip-0.5.0.dist-info/RECORD,,

dash_tooltip-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dash_tooltip-0.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 kb-
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dash_tooltip-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dash_tooltip