figgyplot 0.2.1__cp315-cp315-win_arm64.whl

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,29 @@
+# References and licenses
+
+The integration follows the public model, picking, drag/resize, export and SSOT
+contracts in shim9610/figgy (reference HEAD 84aa2783caa97d679c72b5c079fb4aea8bf1040e)
+and the separation of accepted model state from UI drafts in shim9610/figgy-web
+(reference HEAD b15290af0f5ca83c94bf60b066f9565b7e0d878c). Their renderer code and
+Studio application are not copied into this package.
+
+figgy-renderer and its bundled fonts retain their MIT/Apache-2.0 and OFL notices.
+The font notices are shipped in `figgy/licenses/LICENSE-LiberationSans.txt` and
+`figgy/licenses/LICENSE-ComicNeue.txt`, including when fonts are embedded in the
+native extension.
+The native desktop uses winit/wgpu and egui. PySide6 is optional benchmark-only tooling.
+The notebook extra uses anywidget and ipywidgets under their respective licenses.
+
+## Packaged browser kernel
+
+Generated JS/WASM assets use upstream `figgy` web package 0.13.1 and
+`figgy-renderer` 0.16.1 at commit
+`84aa2783caa97d679c72b5c079fb4aea8bf1040e`, under MIT OR Apache-2.0.
+Rebuild path and asset hashes are documented in `docs/HOSTS.md` and
+`python/figgyplot/assets/provenance.json`. The same bundled font licenses apply.
+
+## Desktop UI fonts
+
+The native egui UI embeds `epaint_default_fonts 0.36.2`'s Hack Regular,
+Ubuntu Light, Noto Emoji Regular and emoji-icon-font. Their complete font
+license texts are included as `python/figgyplot/licenses/LICENSE-Egui-*.txt`
+(Hack/Bitstream terms, Ubuntu Font Licence, SIL OFL and icon-font MIT).

figgyplot/__init__.py

@@ -0,0 +1,6 @@
+"""NumPy-first plots; Rust owns rendering, picking and accepted settings."""
+from .figure import Figure, Axes, Artist, RadialArtist, figure, subplots, text_segments
+from ._native import release_gpu
+
+__version__ = "0.2.1"
+__all__ = ["Figure", "Axes", "Artist", "RadialArtist", "figure", "subplots", "text_segments", "release_gpu"]

figgyplot/_codegen.py

@@ -0,0 +1,156 @@
+"""Readable Python export, shared by native and notebook editors (no GPU access)."""
+from __future__ import annotations
+
+import copy
+import json
+import keyword
+import pprint
+
+
+def settings_to_code(settings, defaults, dpi=120, variable="fig"):
+    from .figure import _code_tree, _diff, _segments
+
+    if not isinstance(variable, str) or not variable.isidentifier() or keyword.iskeyword(variable):
+        raise ValueError("variable must be a Python identifier")
+    if isinstance(settings, str):
+        settings = json.loads(settings)
+    if isinstance(defaults, str):
+        defaults = json.loads(defaults)
+    if settings.get("radial") is not None:
+        chart = copy.deepcopy(settings["radial"])
+        chart["interaction"] = {"hovered": None, "selected": None, "hover_progress": 0.0}
+        chart["decorations"]["selected"] = None
+        slices = {i: {key: value for key, value in item.items() if key != "value"}
+                  for i, item in enumerate(chart.pop("slices"))}
+        chart["slices"] = slices
+        args = pprint.pformat(chart, width=96, sort_dicts=False)
+        canvas = pprint.pformat({"chart_area": settings["config"]["chart_area"]})
+        return (f"# Apply to an existing pie/donut with the same slice count and DPI.\n"
+                f"# Existing category values are preserved.\n"
+                f"{variable}.configure(config={canvas})\n"
+                f"{variable}.configure_radial(expected_slices={len(slices)}, **{args})\n")
+    segments_function = "_text_segments" if variable == "text_segments" else "text_segments"
+    cfg = settings["config"]
+    modeled = copy.deepcopy(defaults)
+    lines = [f"# Apply to the existing {variable} with the same plotted series.",
+             f"ax = {variable}.axes[0]" if variable != "ax" else "_ax = ax.axes[0]",
+             f"{variable}.configure(reset=True)"]
+    axis = "_ax" if variable == "ax" else "ax"
+    if "draw_style" in cfg:
+        draw_style = copy.deepcopy(cfg["draw_style"])
+        mode = draw_style.pop("mode")
+        options = ", ".join(f"{key}={value!r}" for key, value in draw_style.items())
+        lines.append(f"{variable}.set_draw_style({mode!r}" + (f", {options}" if options else "") + ")")
+        modeled["draw_style"] = copy.deepcopy(cfg["draw_style"])
+    if settings.get("background") is not None:
+        color = tuple(settings["background"][key] for key in "rgba")
+        lines.append(f"{variable}.set_facecolor({color!r})")
+
+    for key, method in (("chart_title", "set_title"), ("bottom_x", "set_xlabel"), ("left_y", "set_ylabel")):
+        node = cfg[key] if key == "chart_title" else cfg[key]["title_option"]
+        baseline = modeled[key] if key == "chart_title" else modeled[key]["title_option"]
+        rich = node["text"]
+        value = "".join(s["text"] for s in rich["segments"])
+        args = [repr(value)]
+        baseline["text"]["segments"] = _segments(value)
+        # Python's font sizes are points; the renderer/editor stores pixels.
+        for field, prop, val in (("font_size", "fontsize", rich["font_size"] * 72 / dpi),
+                                 ("font", "font", rich["font"]),
+                                 ("color", "color", tuple(rich["color"][c] for c in "rgba"))):
+            if field == "font_size" or rich[field] != baseline["text"][field]:
+                args.append(f"{prop}={val!r}")
+                baseline["text"][field] = copy.deepcopy(rich[field])
+        if node["visible"] != baseline["visible"]:
+            args.append(f"visible={node['visible']!r}")
+            baseline["visible"] = node["visible"]
+        offset = (node["offset_x"], node["offset_y"])
+        if offset != (baseline["offset_x"], baseline["offset_y"]):
+            args.append(f"offset={offset!r}")
+            baseline["offset_x"], baseline["offset_y"] = offset
+        lines.append(f"{axis}.{method}({', '.join(args)})")
+
+    for dimension, keys in (("x", ("bottom_x", "top_x")), ("y", ("left_y", "right_y"))):
+        primary = cfg[keys[0]]
+        lines.append(f"{axis}.set_{dimension}lim({primary['min']!r}, {primary['max']!r})")
+        for key in keys:
+            modeled[key]["min"], modeled[key]["max"] = primary["min"], primary["max"]
+        if primary["scale"] in ("Linear", "Logarithmic") and all(cfg[k]["scale"] == primary["scale"] for k in keys):
+            scale = "log" if primary["scale"] == "Logarithmic" else "linear"
+            lines.append(f"{axis}.set_{dimension}scale({scale!r})")
+            for key in keys:
+                modeled[key]["scale"] = primary["scale"]
+                modeled[key]["major_spacing"] = 1.0 if scale == "log" else (primary["max"] - primary["min"]) / 5
+    if cfg["grid"]["show_major_x"] == cfg["grid"]["show_major_y"]:
+        visible = cfg["grid"]["show_major_x"]
+        lines.append(f"{axis}.grid({visible!r})")
+        modeled["grid"]["show_major_x"] = modeled["grid"]["show_major_y"] = visible
+
+    series = {}
+    for spec in settings["series"]:
+        sid = spec["series_id"]
+        patch = {k: copy.deepcopy(v) for k, v in spec.items()
+                 if k not in ("series_id", "x_column", "y_column")}
+        style = next(iter(patch["render_type"].values()))
+        properties = {}
+        colors = [(style[k], field) for k, field in
+                  (("line", "line_color"), ("scatter", "point_color"), ("bar", "bar_color")) if k in style]
+        if colors and all(node[field] == colors[0][0][colors[0][1]] for node, field in colors):
+            color = colors[0][0][colors[0][1]]
+            properties["color"] = tuple(color[c] for c in "rgba")
+            for node, field in colors:
+                del node[field]
+        if "line" in style:
+            line = style["line"]
+            properties["linewidth"] = line.pop("line_width") * 72 / dpi
+            properties["linestyle"] = {"Solid": "-", "Dash": "--", "Dot": ":", "DashDot": "-."}.get(line["line_style"], line["line_style"])
+            del line["line_style"]
+        if "scatter" in style:
+            properties["markersize"] = style["scatter"].pop("point_size") * 144 / dpi
+        if patch.get("label") is not None:
+            label = patch["label"]
+            value = "".join(s["text"] for s in label["segments"])
+            properties["label"] = value
+            if label["segments"] == _segments(value):
+                del label["segments"]
+        if properties:
+            args = ", ".join(f"{key}={value!r}" for key, value in properties.items())
+            lines.append(f"{variable}.update({sid!r}, {args})")
+
+        def compact(value):
+            if not isinstance(value, dict):
+                return value
+            return {key: item for key, raw in value.items() if (item := compact(raw)) != {}}
+
+        patch = compact(patch)
+        if patch:
+            series[sid] = patch
+
+    def configure(options):
+        lines.append(f"{variable}.configure(")
+        for key, value in options.items():
+            formatted = pprint.pformat(_code_tree(value, segments_function), width=96, sort_dicts=False)
+            lines.append(f"    {key}=" + formatted.replace("\n", "\n    ") + ",")
+        lines.append(")")
+
+    # Restore advanced series styling before rebuilding the legend so ordinary
+    # labels and renderer-generated symbols need no serialized segment list.
+    if series:
+        lines += ["", "# Preserve advanced series styling."]
+        configure({"series": series})
+    lines.append(f"{axis}.legend(visible={cfg['legend']['visible']!r})")
+    from ._native import rebuild_legend_json
+    modeled["legend"]["content"] = json.loads(rebuild_legend_json(
+        json.dumps(settings["series"]), json.dumps(modeled["legend"]["content"])))
+    modeled["legend"]["visible"] = cfg["legend"]["visible"]
+
+    # Advanced geometry and rich text remain ordinary Python values.
+    # No escaped JSON, data uploads or private renderer IDs are emitted.
+    residual = _diff(modeled, cfg)
+    residual["chart_area"] = copy.deepcopy(cfg["chart_area"])
+    lines += ["", "# Preserve advanced layout."]
+    configure({"config": residual})
+    code = "\n".join(lines) + "\n"
+    if f"{segments_function}(" in code:
+        alias = "" if segments_function == "text_segments" else f" as {segments_function}"
+        code = f"from figgyplot import text_segments{alias}\n\n" + code
+    return code