fastplotpy 0.3.0a1__py3-none-win_amd64.whl

fastplotpy/heatmap_labels.py

@@ -0,0 +1,146 @@
+"""Source-compatible heatmap cell labels and fill contrast."""
+
+from __future__ import annotations
+
+import re
+from decimal import Decimal, ROUND_HALF_UP
+from math import floor, isfinite
+from typing import Mapping
+
+from .defaults import get_defaults
+
+
+def _number(value, fallback, positive=False):
+    if isinstance(value, bool) or not isinstance(value, (int, float)) or not isfinite(value):
+        return fallback
+    if value <= 0 if positive else value < 0:
+        return fallback
+    return value
+
+
+def resolve_labels(plot_input, trace_input):
+    defaults = get_defaults("heatmap")["cellLabels"]
+    result = dict(defaults)
+    for source in (plot_input, trace_input):
+        if source is None:
+            continue
+        if isinstance(source, bool):
+            result["show"] = source
+            continue
+        if not isinstance(source, Mapping):
+            continue
+        result["show"] = source.get("show", True)
+        color = source.get("color")
+        if isinstance(color, str) and color.strip():
+            result["color"] = color
+            result["autoContrast"] = False
+        for key in ("font", "prefix", "suffix"):
+            if isinstance(source.get(key), str):
+                result[key] = source[key]
+        for key in ("lineHeight", "padding", "minCellWidth", "minCellHeight"):
+            if key in source:
+                result[key] = _number(source[key], result[key], key == "lineHeight")
+        if "decimals" in source:
+            value = source["decimals"]
+            if isinstance(value, (int, float)) and not isinstance(value, bool) and isfinite(value):
+                result["decimals"] = max(0, min(6, floor(value + .5)))
+    return result
+
+
+def _parse_color(value):
+    if not isinstance(value, str):
+        return None
+    value = value.strip().lower()
+    match = re.fullmatch(r"#([0-9a-f]{3}|[0-9a-f]{6})", value)
+    if match:
+        digits = match.group(1)
+        if len(digits) == 3:
+            digits = "".join(digit * 2 for digit in digits)
+        return tuple(int(digits[index:index + 2], 16) for index in (0, 2, 4))
+    match = re.fullmatch(r"rgba?\(\s*([\d.]+)[,\s]+([\d.]+)[,\s]+([\d.]+)(?:\s*[,/]\s*[\d.]+)?\s*\)", value)
+    if match:
+        return tuple(max(0, min(255, float(item))) for item in match.groups()[:3])
+    return None
+
+
+def _contrast(foreground, background):
+    first, second = _parse_color(foreground), _parse_color(background)
+    if first is None or second is None:
+        return None
+    def luminance(color):
+        channels = []
+        for value in color:
+            normalized = value / 255
+            channels.append(normalized / 12.92 if normalized <= .04045 else ((normalized + .055) / 1.055) ** 2.4)
+        return .2126 * channels[0] + .7152 * channels[1] + .0722 * channels[2]
+    a, b = luminance(first), luminance(second)
+    return (max(a, b) + .05) / (min(a, b) + .05)
+
+
+def _label_color(labels, fill):
+    color = labels["color"]
+    if not labels["autoContrast"]:
+        return color
+    defaults = get_defaults("heatmap")["cellLabels"]
+    contrast = _contrast(color, fill)
+    if contrast is None or contrast >= defaults["minimumContrastRatio"]:
+        return color
+    for candidate in (defaults["lightTextColor"], defaults["darkTextColor"]):
+        if (_contrast(candidate, fill) or 0) > (_contrast(color, fill) or 0):
+            color = candidate
+    if (_contrast(color, fill) or 0) >= defaults["minimumContrastRatio"]:
+        return color
+    for candidate in ("#ffffff", "#000000"):
+        if (_contrast(candidate, fill) or 0) > (_contrast(color, fill) or 0):
+            color = candidate
+    return color
+
+
+def _fixed(value, decimals):
+    if decimals <= 0:
+        return str(floor(value + .5))
+    quantum = Decimal(1).scaleb(-decimals)
+    return format(Decimal(str(value)).quantize(quantum, rounding=ROUND_HALF_UP), f".{decimals}f")
+
+
+def _compact(value, prefix, suffix):
+    defaults = get_defaults("heatmap")["cellLabels"]
+    decimals = defaults["compactDecimals"]
+    for threshold, symbol in ((1e12, "T"), (1e9, "B"), (1e6, "M"), (1e3, "k")):
+        if abs(value) >= threshold:
+            label = _fixed(value / threshold, decimals).rstrip("0").rstrip(".")
+            return f"{prefix}{label}{symbol}{suffix}"
+    if 0 < abs(value) < .001:
+        mantissa, exponent = f"{value:.{decimals}e}".split("e")
+        return f"{prefix}{mantissa}e{int(exponent):+d}{suffix}"
+    return f"{prefix}{_fixed(value, decimals)}{suffix}"
+
+
+def build_cell_labels(cells, labels, border_width):
+    if not labels["show"]:
+        return None
+    output = []
+    for cell in cells:
+        if cell.get("missing"):
+            continue
+        value = cell["value"]
+        text = f"{labels['prefix']}{_fixed(value, labels['decimals'])}{labels['suffix']}"
+        compact = _compact(value, labels["prefix"], labels["suffix"])
+        item = {"x": cell["x"] + cell["width"] / 2, "y": cell["y"] + cell["height"] / 2,
+                "value": value, "xValue": cell["xValue"], "yValue": cell["yValue"],
+                "row": cell["row"], "column": cell["column"], "text": text, "fullText": text}
+        if len(compact) < len(text):
+            item["compactText"] = compact
+        for source, target in (("sourceIndex", "sourceIndex"), ("xCategory", "xCategory"),
+                               ("yCategory", "yCategory"), ("cornerRadius", "cellCornerRadius")):
+            if source in cell:
+                item[target] = cell[source]
+        item.update({"cellX": cell["x"], "cellY": cell["y"], "cellWidth": cell["width"],
+                     "cellHeight": cell["height"]})
+        if border_width > 0:
+            item["cellBorderWidth"] = border_width
+        item.update({"lineHeight": labels["lineHeight"], "padding": labels["padding"],
+                     "minCellWidth": labels["minCellWidth"], "minCellHeight": labels["minCellHeight"],
+                     "color": _label_color(labels, cell["fillColor"]), "font": labels["font"]})
+        output.append(item)
+    return output or None

fastplotpy/interactions.py

@@ -0,0 +1,243 @@
+"""Python counterparts of the source's public viewport state helpers."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from math import isfinite
+from sys import float_info
+from typing import Any, Mapping
+
+from .subplots import resolveTraceSubplotBindings
+from .scene import _domain, _number
+
+
+def resolveSharedAxisInteractionPatch(options: Mapping[str, Any]) -> dict:
+    mode = options.get("mode", "xy")
+    active = [binding for binding in options["bindings"]
+              if binding["subplotId"] == options["activeSubplotId"]]
+    if not active:
+        raise ValueError(f"Unknown subplot id '{options['activeSubplotId']}' for interaction")
+    patch = {"xAxes": {}, "yAxes": {}}
+    for letter in "xy":
+        if letter in mode and options.get(f"{letter}Range"):
+            for binding in active:
+                patch[f"{letter}Axes"][binding[f"{letter}AxisId"]] = deepcopy(options[f"{letter}Range"])
+    return patch
+
+
+def mergeAxisViewportState(current: Mapping | None, patch: Mapping) -> dict | None:
+    x_axes = deepcopy((current or {}).get("xAxes") or {})
+    y_axes = deepcopy((current or {}).get("yAxes") or {})
+    for axis_id in patch.get("resetXAxes") or []:
+        x_axes.pop(axis_id, None)
+    for axis_id in patch.get("resetYAxes") or []:
+        y_axes.pop(axis_id, None)
+    x_axes.update(deepcopy(patch.get("xAxes") or {}))
+    y_axes.update(deepcopy(patch.get("yAxes") or {}))
+    state = {}
+    if x_axes:
+        state["xAxes"] = x_axes
+    if y_axes:
+        state["yAxes"] = y_axes
+    return state or None
+
+
+def viewportStateToAxesOptions(axes: Mapping | None, viewport: Mapping | None) -> dict | None:
+    if not viewport or not (viewport.get("xAxes") or viewport.get("yAxes")):
+        return deepcopy(axes)
+    result = deepcopy(dict(axes or {}))
+    for dimension in ("xAxes", "yAxes"):
+        result[dimension] = deepcopy(result.get(dimension) or {})
+        for axis_id, range_value in (viewport.get(dimension) or {}).items():
+            result[dimension][axis_id] = {**result[dimension].get(axis_id, {}),
+                                          "range": deepcopy(range_value)}
+    return result
+
+
+def resolveInteractionBindingsFromPlotOptions(options: Mapping) -> list[dict]:
+    return [{"subplotId": binding["subplotId"], "xAxisId": binding["xAxisId"],
+             "yAxisId": binding["yAxisId"]}
+            for binding in resolveTraceSubplotBindings(options)]
+
+
+def resolveLinkedAxisViewportPatch(options: Mapping, patch: Mapping) -> dict:
+    result = {"xAxes": deepcopy(patch.get("xAxes") or {}),
+              "yAxes": deepcopy(patch.get("yAxes") or {})}
+    for dimension, letter in (("xAxes", "x"), ("yAxes", "y")):
+        axes = deepcopy(((options.get("axes") or {}).get(dimension) or {}))
+        axes.setdefault(letter, {})
+        groups: dict[str, list[tuple[str, dict]]] = {}
+        for axis_id, axis in axes.items():
+            group_id = axis.get("viewportGroup")
+            if group_id is None:
+                continue
+            if not isinstance(group_id, str) or not group_id.strip():
+                raise ValueError(f"{letter}-axis '{axis_id}' viewportGroup must be a non-empty string")
+            groups.setdefault(group_id.strip(), []).append((axis_id, axis))
+        resets = list(dict.fromkeys(patch.get("reset" + letter.upper() + "Axes") or []))
+        for group_id, members in groups.items():
+            scales = {axis.get("scale", "linear") for _, axis in members}
+            if len(scales) > 1:
+                raise ValueError(f"{letter}-axis viewportGroup '{group_id}' requires matching scale types")
+            categories = [axis.get("categories") for _, axis in members]
+            if any(value != categories[0] for value in categories):
+                raise ValueError(f"{letter}-axis viewportGroup '{group_id}' requires matching categories")
+            ranges = [(result[dimension][axis_id], axis) for axis_id, axis in members
+                      if axis_id in result[dimension]]
+            if ranges:
+                first, first_axis = ranges[0]
+                first_pair = (_number(first["min"], first_axis), _number(first["max"], first_axis))
+                if any((_number(value["min"], axis), _number(value["max"], axis)) != first_pair
+                       for value, axis in ranges[1:]):
+                    raise ValueError(f"viewportGroup '{group_id}' received conflicting ranges")
+                for axis_id, _ in members:
+                    result[dimension][axis_id] = deepcopy(first)
+                    if axis_id in resets:
+                        resets.remove(axis_id)
+            elif any(axis_id in resets for axis_id, _ in members):
+                for axis_id, _ in members:
+                    if axis_id not in resets:
+                        resets.append(axis_id)
+        if resets:
+            result["reset" + letter.upper() + "Axes"] = resets
+    return result
+
+
+def resolveLinkedAxisViewportState(options: Mapping) -> dict | None:
+    viewport = options.get("viewport") or {}
+    patch = resolveLinkedAxisViewportPatch(options, {
+        "xAxes": viewport.get("xAxes") or {}, "yAxes": viewport.get("yAxes") or {},
+    })
+    return mergeAxisViewportState(None, patch)
+
+
+def applyAxisViewportState(options: Mapping, viewport: Mapping | None) -> dict:
+    result = deepcopy(dict(options))
+    linked = resolveLinkedAxisViewportState({"axes": result.get("axes"), "viewport": viewport})
+    result["axes"] = viewportStateToAxesOptions(result.get("axes"), linked)
+    return result
+
+
+def _interaction_context(input_options: Mapping) -> tuple[dict, list, dict]:
+    options = input_options["options"]
+    bindings = resolveTraceSubplotBindings(options)
+    active = [item for item in bindings if item["subplotId"] == input_options["activeSubplotId"]]
+    if not active:
+        raise ValueError(f"Unknown subplot id '{input_options['activeSubplotId']}' for interaction")
+    return options, active, {"xAxes": {}, "yAxes": {}}
+
+
+def _axis_domains(options: Mapping, axis_id: str, letter: str):
+    resolved = applyAxisViewportState(options, options.get("viewport"))
+    dimension = f"{letter}Axes"
+    current_axis = ((resolved.get("axes") or {}).get(dimension) or {}).get(axis_id) or {}
+    base_axis = ((options.get("axes") or {}).get(dimension) or {}).get(axis_id) or {}
+    values = []
+    for binding in resolveTraceSubplotBindings(options):
+        if binding["trace"].get("visible") is False or binding[f"{letter}AxisId"] != axis_id:
+            continue
+        for point in binding["trace"].get("data") or []:
+            if point.get(letter) is not None:
+                values.append(_number(point[letter], current_axis))
+    return _domain(values, current_axis), _domain(values, base_axis), current_axis
+
+
+def _axis_ids(bindings, letter):
+    return list(dict.fromkeys(item[f"{letter}AxisId"] for item in bindings))
+
+
+def _unit(value):
+    return max(0, min(1, value)) if isinstance(value, (int, float)) and isfinite(value) else .5
+
+
+def _range(domain, axis):
+    low, high = domain
+    if axis.get("scale") == "logarithmic":
+        low, high = 10 ** low, 10 ** high
+    return {"min": low, "max": high}
+
+
+def _same_domain(left, right):
+    tolerance = float_info.epsilon * max(1, *(abs(value) for value in (*left, *right))) * 16
+    return abs(left[0] - right[0]) <= tolerance and abs(left[1] - right[1]) <= tolerance
+
+
+def resolveAxisZoomInteractionPatch(input_options: Mapping) -> dict:
+    options, active, patch = _interaction_context(input_options)
+    mode = input_options.get("mode", "xy")
+    scale = input_options["scale"]
+    for letter in "xy":
+        if letter not in mode:
+            continue
+        dimension = f"{letter}Axes"
+        ratio = input_options[f"{letter}Ratio"]
+        ratio = _unit(ratio if letter == "x" else 1 - ratio)
+        for axis_id in _axis_ids(active, letter):
+            domain, base, axis = _axis_domains(options, axis_id, letter)
+            if domain is None or not isinstance(scale, (int, float)) or not isfinite(scale) or scale <= 0:
+                continue
+            low, high = domain
+            span = max((high - low) * scale, float_info.epsilon)
+            center = low + (high - low) * ratio
+            zoomed = (center - span * ratio, center + span * (1 - ratio))
+            if scale > 1 and base is not None:
+                if high - low >= base[1] - base[0]:
+                    continue
+                zoomed = (max(base[0], zoomed[0]), min(base[1], zoomed[1]))
+                if zoomed[0] >= zoomed[1]:
+                    continue
+                if _same_domain(zoomed, base):
+                    patch.setdefault("reset" + letter.upper() + "Axes", []).append(axis_id)
+                    continue
+            patch[dimension][axis_id] = _range(zoomed, axis)
+    return resolveLinkedAxisViewportPatch(options, patch)
+
+
+def resolveAxisBoxZoomInteractionPatch(input_options: Mapping) -> dict:
+    options, active, patch = _interaction_context(input_options)
+    mode = input_options.get("mode", "xy")
+    for letter in "xy":
+        if letter not in mode:
+            continue
+        for axis_id in _axis_ids(active, letter):
+            domain, _, axis = _axis_domains(options, axis_id, letter)
+            if domain is None:
+                continue
+            first = input_options[f"{letter}StartRatio"]
+            second = input_options[f"{letter}EndRatio"]
+            if letter == "y":
+                first, second = 1 - first, 1 - second
+            start, end = _unit(min(first, second)), _unit(max(first, second))
+            if start >= end:
+                continue
+            low, high = domain
+            patch[f"{letter}Axes"][axis_id] = _range((low + (high - low) * start,
+                                                        low + (high - low) * end), axis)
+    return resolveLinkedAxisViewportPatch(options, patch)
+
+
+def resolveAxisPanInteractionPatch(input_options: Mapping) -> dict:
+    options, active, patch = _interaction_context(input_options)
+    mode = input_options.get("mode", "xy")
+    for letter in "xy":
+        if letter not in mode:
+            continue
+        ratio = input_options[f"{letter}Ratio"]
+        if not isinstance(ratio, (int, float)) or not isfinite(ratio) or ratio == 0:
+            continue
+        for axis_id in _axis_ids(active, letter):
+            domain, base, axis = _axis_domains(options, axis_id, letter)
+            if domain is None or domain[0] >= domain[1]:
+                continue
+            span = domain[1] - domain[0]
+            next_range = (domain[0] + span * ratio, domain[1] + span * ratio)
+            if base is not None:
+                if span >= base[1] - base[0]:
+                    continue
+                if next_range[0] < base[0]:
+                    next_range = (base[0], base[0] + span)
+                elif next_range[1] > base[1]:
+                    next_range = (base[1] - span, base[1])
+            if not _same_domain(next_range, domain):
+                patch[f"{letter}Axes"][axis_id] = _range(next_range, axis)
+    return resolveLinkedAxisViewportPatch(options, patch)