uplot-python 0.0.1__tar.gz → 1.0.0__tar.gz

{uplot_python-0.0.1 → uplot_python-1.0.0}/CHANGELOG.md

@@ -7,7 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.0.1] - 2024-10-29
+## [1.0.0] - 2024-10-29
 
 - Extract this project from [foxplot](https://github.com/stephane-caron/foxplot)
 - Start this changelog

uplot_python-1.0.0/MANIFEST.in

@@ -0,0 +1 @@
+include uplot/static/uPlot.*

{uplot_python-0.0.1 → uplot_python-1.0.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: uplot-python
-Version: 0.0.1
-Summary: Plot Python iterables with µPlot.
+Version: 1.0.0
+Summary: Python wrapper for μPlot time series.
 Keywords: json,time,series,plot
 Author-email: Stéphane Caron <stephane.caron@normalesup.org>
 Maintainer-email: Stéphane Caron <stephane.caron@normalesup.org>
@@ -29,3 +29,52 @@ Project-URL: Tracker, https://github.com/stephane-caron/uplot-python/issues
 
 Python wrapper for [μPlot](https://github.com/leeoniya/uPlot) 📈
 
+## Installation
+
+### From PyPI
+
+```console
+pip install uplot-python
+```
+
+## Usage
+
+The `plot` function has the same API as µPlot's `uPlot.plot`:
+
+```py
+import numpy as np
+import uplot
+
+t = np.linspace(0.0, 1.0, 10)
+data = [t, np.exp(0.42 * t)]
+opts = {
+    "width": 1920,
+    "height": 600,
+    "title": "Example with plot",
+    "series": [{}, { "stroke": "red", }, ],
+}
+
+uplot.plot(opts, data)
+```
+
+For convenience, the library also provides a `plot2` function with additional defaults aimed at time series and line plots, for an experience closer to `matplotlib.pyplot.plot`:
+
+```py
+import numpy as np
+import uplot
+
+t = np.linspace(0.0, 1.0, 10)
+uplot.plot2(
+    t,
+    [np.exp(0.1 * t), np.exp(-10.0 * t), np.cos(t)],
+    title="Example with plot2",
+    left_labels=["exp(A t)", "exp(-B t)", "cos(t)"],
+)
+```
+
+## See also
+
+- [µPlot](https://github.com/leeoniya/uPlot): A small (~45 KB min), fast chart for time series, lines, areas, ohlc & bars.
+- [Matplotlib](https://matplotlib.org/stable/): Comprehensive library for creating static, animated, and interactive visualizations.
+- [matplotlive](https://github.com/stephane-caron/matplotlive): Stream live plots to a Matplotlib figure.
+

uplot_python-1.0.0/README.md

@@ -0,0 +1,52 @@
+# uplot-python
+
+Python wrapper for [μPlot](https://github.com/leeoniya/uPlot) 📈
+
+## Installation
+
+### From PyPI
+
+```console
+pip install uplot-python
+```
+
+## Usage
+
+The `plot` function has the same API as µPlot's `uPlot.plot`:
+
+```py
+import numpy as np
+import uplot
+
+t = np.linspace(0.0, 1.0, 10)
+data = [t, np.exp(0.42 * t)]
+opts = {
+    "width": 1920,
+    "height": 600,
+    "title": "Example with plot",
+    "series": [{}, { "stroke": "red", }, ],
+}
+
+uplot.plot(opts, data)
+```
+
+For convenience, the library also provides a `plot2` function with additional defaults aimed at time series and line plots, for an experience closer to `matplotlib.pyplot.plot`:
+
+```py
+import numpy as np
+import uplot
+
+t = np.linspace(0.0, 1.0, 10)
+uplot.plot2(
+    t,
+    [np.exp(0.1 * t), np.exp(-10.0 * t), np.cos(t)],
+    title="Example with plot2",
+    left_labels=["exp(A t)", "exp(-B t)", "cos(t)"],
+)
+```
+
+## See also
+
+- [µPlot](https://github.com/leeoniya/uPlot): A small (~45 KB min), fast chart for time series, lines, areas, ohlc & bars.
+- [Matplotlib](https://matplotlib.org/stable/): Comprehensive library for creating static, animated, and interactive visualizations.
+- [matplotlive](https://github.com/stephane-caron/matplotlive): Stream live plots to a Matplotlib figure.

uplot_python-1.0.0/examples/left_right_axes.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 Inria
+
+import numpy as np
+
+import uplot
+
+v1 = np.array(
+    [
+        0.35189867,
+        0.33440887,
+        0.31187567,
+        0.29372533,
+        0.28205933,
+        0.28579414,
+        0.29055172,
+        0.29449164,
+        0.28745652,
+        0.27642006,
+        0.26409361,
+        0.24920144,
+        0.21968901,
+        0.1903474,
+        0.14416688,
+        0.1013935,
+        0.06975446,
+        0.05133968,
+        0.0492436,
+        0.05916173,
+        0.06069822,
+        0.05255136,
+        0.03641129,
+        0.01232885,
+        -0.02340249,
+        -0.06951351,
+        -0.12411359,
+        -0.18078907,
+        -0.23323237,
+        -0.27583448,
+        -0.31259793,
+        -0.33245975,
+        -0.32182605,
+        -0.27193381,
+        -0.1870999,
+        -0.09126389,
+        -0.01173261,
+        0.01668092,
+        0.00449685,
+        -0.03245584,
+        -0.07189206,
+        -0.09525084,
+    ]
+)
+v2 = np.array(
+    [
+        0.40215528,
+        0.38603891,
+        0.35140285,
+        0.3215263,
+        0.27873781,
+        0.27077387,
+        0.24593958,
+        0.28406281,
+        0.29895396,
+        0.28722011,
+        0.25734356,
+        0.27006701,
+        0.27350706,
+        0.25635396,
+        0.21898472,
+        0.17379291,
+        0.08331504,
+        0.03039491,
+        -0.00202633,
+        -0.00801106,
+        0.01757721,
+        0.03845309,
+        0.04877323,
+        0.03812323,
+        0.03562566,
+        0.03322234,
+        -0.01041438,
+        -0.06894225,
+        -0.13345486,
+        -0.18703472,
+        -0.24862564,
+        -0.31921723,
+        -0.40314488,
+        -0.44697009,
+        -0.40724466,
+        -0.29188537,
+        -0.12044866,
+        0.03199712,
+        0.10329557,
+        0.10706548,
+        0.01050863,
+        -0.04231725,
+    ]
+)
+u = np.array(
+    [
+        6.31617203,
+        6.14966762,
+        5.69570748,
+        4.84433587,
+        4.62913678,
+        4.51132705,
+        3.91756604,
+        4.66997748,
+        4.9165925,
+        5.0029863,
+        4.78307482,
+        4.5333182,
+        4.75794207,
+        4.43121644,
+        3.68980057,
+        2.83057498,
+        1.02101761,
+        0.04555309,
+        0.18064158,
+        -0.02199115,
+        0.40840704,
+        0.80896011,
+        0.94561939,
+        0.69272118,
+        0.49480084,
+        0.44610616,
+        -0.0408407,
+        -1.22836273,
+        -2.37975644,
+        -3.24212362,
+        -4.06836249,
+        -5.40353936,
+        -6.76227819,
+        -7.06544188,
+        -6.70572952,
+        -5.23703495,
+        -1.99805293,
+        0.25289821,
+        1.52053084,
+        1.53623881,
+        0.01413717,
+        -0.73356188,
+    ]
+)
+
+if __name__ == "__main__":
+    t = np.linspace(0.0, 1.0, len(v1))
+    uplot.plot2(
+        t,
+        left=[v1, v2],
+        right=[u],
+        title="Plot with left and right axes",
+        left_labels=["v1", "v2"],
+        right_labels=["u"],
+    )

uplot_python-1.0.0/examples/simple_plot.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 Inria
+
+import numpy as np
+
+import uplot
+
+if __name__ == "__main__":
+    t = np.linspace(0.0, 1.0, 10)
+    data = [
+        t,
+        np.exp(0.42 * t),
+    ]
+    opts = {
+        "width": 1920,
+        "height": 600,
+        "title": "Simple plot",
+        "scales": {
+            "x": {
+                "time": False,
+            },
+        },
+        "series": [
+            {},
+            {
+                "stroke": "red",
+                "fill": "rgba(255,0,0,0.1)",
+            },
+        ],
+    }
+    uplot.plot(opts, data)

uplot_python-1.0.0/examples/simple_plot2.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 Inria
+
+import numpy as np
+
+import uplot
+
+if __name__ == "__main__":
+    t = np.linspace(0.0, 1.0, 10)
+    uplot.plot2(
+        t,
+        [np.exp(0.1 * t), np.exp(-10.0 * t), np.cos(t)],
+        title="Simple plot",
+        left_labels=["exp(0.1 t)", "exp(-K t)", "cos(t)"],
+    )

{uplot_python-0.0.1 → uplot_python-1.0.0}/uplot/__init__.py

@@ -5,10 +5,14 @@
 # Copyright 2022 Stéphane Caron
 # Copyright 2023-2024 Inria
 
-"""Plot Python iterables with µPlot."""
+"""Python wrapper for μPlot time series."""
 
-__version__ = "0.0.1"
+__version__ = "1.0.0"
 
 from .plot import plot
+from .plot2 import plot2
 
-__all__ = ["plot"]
+__all__ = [
+    "plot",
+    "plot2",
+]

uplot_python-1.0.0/uplot/generate_html.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2022 Stéphane Caron
+# Copyright 2023 Inria
+
+"""Generate an HTML page containing the output plot."""
+
+import json
+from datetime import datetime
+from importlib import resources
+from typing import List
+
+import numpy as np
+
+from .utils import array2string, js
+
+
+def generate_html(opts: dict, data: List[np.ndarray], resize: bool) -> str:
+    """Generate plot in an HTML page.
+
+    Args:
+        opts: uPlot option dictionary.
+        data: List of NumPy arrays, one for each series in the plot.
+
+    Returns:
+        HTML contents of the page.
+    """
+    with resources.path("uplot.static", "uPlot.min.css") as path:
+        uplot_min_css = path
+    with resources.path("uplot.static", "uPlot.iife.js") as path:
+        uplot_iife_js = path
+    with resources.path("uplot.static", "uPlot.mousewheel.js") as path:
+        uplot_mwheel_js = path
+
+    date = datetime.now().strftime("%Y%m%d-%H%M%S")
+    title = opts.get("title", f"Plot from {date}")
+
+    data_string = ""
+    for array in data:
+        data_string += f"""
+                {array2string(array)},"""
+
+    if "class" not in opts:
+        opts["class"] = "uplot-chart"
+    if resize:
+        opts["width"] = js("window.innerWidth - 20")
+        opts["height"] = js("window.innerHeight - 150")
+    opts_string = json.dumps(opts)
+    opts_string = opts_string.replace('"<script>', "")
+    opts_string = opts_string.replace('</script>"', "")
+
+    html = f"""<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="utf-8">
+        <title>{title}</title>
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <link rel="stylesheet" href="{uplot_min_css}">
+        <style>
+            div.uplot-chart {{
+                background-color: white;
+                padding: 10px 0px;  // appear in Right Click -> Take Screenshot
+            }}
+        </style>
+    </head>
+    <body>
+        <script src="{uplot_iife_js}"></script>
+        <script src="{uplot_mwheel_js}"></script>
+        <script>
+            const {{ linear, stepped, bars, spline, spline2 }} = uPlot.paths;
+
+            let data = [{data_string}
+            ];
+
+            const lineInterpolations = {{
+                linear: 0,
+                stepAfter: 1,
+                stepBefore: 2,
+                spline: 3,
+            }};
+
+            const _stepBefore = stepped({{align: -1}});
+            const _stepAfter = stepped({{align:  1}});
+            const _linear = linear();
+            const _spline = spline();
+
+            function paths(u, seriesIdx, idx0, idx1, extendGap, buildClip) {{
+                let s = u.series[seriesIdx];
+                let interp = s.lineInterpolation;
+
+                let renderer = (
+                    interp == lineInterpolations.linear ? _linear :
+                    interp == lineInterpolations.stepAfter ? _stepAfter :
+                    interp == lineInterpolations.stepBefore ? _stepBefore :
+                    interp == lineInterpolations.spline ? _spline :
+                    null
+                );
+
+                return renderer(
+                    u, seriesIdx, idx0, idx1, extendGap, buildClip
+                );
+            }}
+
+            let opts = {opts_string};
+            let uplot = new uPlot(opts, data, document.body);"""
+    if resize:
+        html += """
+
+            window.addEventListener("resize", e => {
+                uplot.setSize({
+                    width: window.innerWidth - 20,
+                    height: window.innerHeight - 150,
+                });
+            });"""
+    html += """
+        </script>
+    </body>
+</html>"""
+    return html

uplot_python-1.0.0/uplot/plot.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 Inria
+
+"""Main plot function."""
+
+import webbrowser
+from typing import Iterable, List
+
+from .generate_html import generate_html
+from .write_html_tempfile import write_html_tempfile
+
+
+def plot(opts: dict, data: List[Iterable]) -> None:
+    """Plot function with the same API as uPlot's `plot`.
+
+    Args:
+        opts: Options dictionary, as expected by uPlot.
+        data: List of series, as expected by uPlot.
+    """
+    html = generate_html(opts, data, resize=False)
+    filename = write_html_tempfile(html)
+    webbrowser.open_new_tab(filename)

uplot_python-1.0.0/uplot/plot2.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 Inria
+
+"""Additional plot function."""
+
+import webbrowser
+from typing import List, Optional
+
+import numpy as np
+
+from .color_picker import ColorPicker
+from .exceptions import UplotException
+from .generate_html import generate_html
+from .utils import js
+from .write_html_tempfile import write_html_tempfile
+
+
+def prepare_data(x, left, right):
+    if isinstance(left, np.ndarray) and left.ndim == 1:
+        left = [left]
+    data = [x, *left]
+    if right:
+        data.extend(right)
+    return data
+
+
+def add_default_options(opts: dict) -> None:
+    if "cursor" not in opts:
+        opts["cursor"] = {
+            "drag": {
+                "x": True,
+                "y": True,
+                "uni": 50,
+            }
+        }
+    if "plugins" not in opts:
+        opts["plugins"] = [
+            js("wheelZoomPlugin({factor: 0.75})"),
+        ]
+
+
+def add_series(
+    opts: dict,
+    data: List[np.ndarray],
+    nb_left: int,
+    left_labels: Optional[List[str]],
+    right_labels: Optional[List[str]],
+) -> None:
+    if left_labels is not None and len(left_labels) < nb_left:
+        raise UplotException(
+            f"Not enough labels in left_labels ({len(left_labels)}) "
+            f"to label all {nb_left} left-axis series"
+        )
+
+    opts["series"] = [{}]
+    color_picker = ColorPicker()
+    for i, series in enumerate(data[1:]):
+        new_series = {
+            "show": True,
+            "spanGaps": False,
+            "stroke": color_picker.get_next_color(),
+            "width": js("2 / devicePixelRatio"),
+        }
+
+        def find_in_lists(
+            i: int,
+            left_list: Optional[List[str]],
+            right_list: Optional[List[str]],
+        ) -> Optional[str]:
+            return None
+
+        if left_labels is not None and i < nb_left:
+            new_series["label"] = left_labels[i]
+        if i >= nb_left:
+            if right_labels is not None:
+                new_series["label"] = right_labels[i - nb_left]
+            new_series["scale"] = "right_axis"
+
+        # scale = find_in_lists(i, left_scales, right_scales)
+        # if scale is not None:
+        #     new_series["scale"] = scale
+
+        new_series["value"] = js(
+            "(self, rawValue) => Number.parseFloat(rawValue).toPrecision(2)"
+        )
+
+        # Last, we hack the wrapper to append `paths` after "lineInterpolation"
+        new_series["lineInterpolation"] = js(
+            "lineInterpolations.stepAfter, paths"
+        )
+        opts["series"].append(new_series)
+
+
+def add_axes(opts: dict) -> None:
+    opts["axes"] = [
+        {},
+        {
+            "size": 60,
+        },
+        {
+            "side": 1,
+            "scale": "right_axis",
+            "size": 60,
+            "grid": {"show": False},
+        },
+    ]
+
+
+def plot2(
+    x: np.ndarray,
+    left: List[np.ndarray],
+    right: Optional[List[np.ndarray]] = None,
+    resize: bool = True,
+    title: Optional[str] = None,
+    timestamped: bool = False,
+    width: Optional[int] = None,
+    height: Optional[int] = None,
+    left_labels: Optional[List[str]] = None,
+    right_labels: Optional[List[str]] = None,
+    **kwargs,
+) -> None:
+    """Plot function with additional defaults and parameters.
+
+    Args:
+        x: Values for the x-axis.
+        left: Values for the left y-axis.
+        right: Values for the (optional) right y-axis.
+        resize: If set (default), scale plot to page width and height.
+        title: Plot title.
+        timestamped: If set, x-axis values are treated as timestamps.
+        width: Plot width in pixels.
+        height: Plot height in pixels.
+        kwargs: Other keyword arguments are forward to uPlot as options.
+    """
+    data = prepare_data(x, left, right)
+
+    # Prepare options
+    opts = kwargs.copy()
+    add_default_options(opts)
+    if "id" not in opts:
+        opts["id"] = "chart1"
+    if title is not None:
+        opts["title"] = title
+    if timestamped is not None:
+        opts["scales"] = {"x": {"time": timestamped}}
+    if width is not None:
+        opts["width"] = width
+    if height is not None:
+        opts["height"] = height
+    if "series" not in opts:
+        add_series(opts, data, len(left), left_labels, right_labels)
+    if "axes" not in opts:
+        add_axes(opts)
+
+    # Generate and open plot
+    html = generate_html(opts, data, resize=resize)
+    filename = write_html_tempfile(html)
+    webbrowser.open_new_tab(filename)

uplot_python-1.0.0/uplot/utils.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 Inria
+
+import numpy as np
+
+
+def array2string(array: np.ndarray) -> str:
+    """Get string representation of a NumPy array suitable for uPlot.
+
+    Args:
+        array: NumPy array to convert to JavaScript.
+
+    Returns:
+        String representation of the array.
+    """
+    array_str = np.array2string(
+        array,
+        precision=64,
+        separator=",",
+        threshold=np.inf,
+    )
+    return array_str.replace("nan", "null")
+
+
+def js(code: str) -> str:
+    """Wrap a code string so that it is processed as output JavaScript.
+
+    Args:
+        code: Code string to wrap.
+
+    Returns:
+        Wrapped string.
+    """
+    return f"<script>{code}</script>"

uplot_python-0.0.1/uplot/write_tmpfile.py → uplot_python-1.0.0/uplot/write_html_tempfile.py

@@ -11,14 +11,14 @@ import tempfile
 from datetime import datetime
 
 
-def write_tmpfile(html: str) -> str:
-    """Write output page.
+def write_html_tempfile(html: str) -> str:
+    """Write string to an HTML file.
 
     Args:
         html: HTML content.
 
     Returns:
-        Name of the output file (a temporary file).
+        Name of the output temporary file.
     """
     filename: str = ""
     with tempfile.NamedTemporaryFile(

uplot_python-0.0.1/MANIFEST.in

@@ -1 +0,0 @@
-include uplot/uplot/uPlot.*

uplot_python-0.0.1/README.md

@@ -1,3 +0,0 @@
-# uplot-python
-
-Python wrapper for [μPlot](https://github.com/leeoniya/uPlot) 📈

uplot_python-0.0.1/examples/simple_plot.py

@@ -1,12 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-# SPDX-License-Identifier: Apache-2.0
-# Copyright 2024 Inria
-
-import numpy as np
-import uplot
-
-if __name__ == "__main__":
-    t = np.arange(10)
-    uplot.plot(t, np.exp(0.42 * t))

uplot_python-0.0.1/uplot/generate_html.py

@@ -1,228 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-# SPDX-License-Identifier: Apache-2.0
-# Copyright 2022 Stéphane Caron
-# Copyright 2023 Inria
-
-"""Generate an HTML page containing the output plot."""
-
-from importlib import resources
-from math import isnan
-from typing import Dict, Iterable, List
-
-import numpy as np
-from numpy.typing import NDArray
-
-from .color_picker import ColorPicker
-
-
-def __ensure_floats(series: Iterable) -> List[float]:
-    return [float(x) for x in series]
-
-
-def __escape_null(series: Iterable) -> str:
-    """Escape undefined values in a series.
-
-    Args:
-        series: Series to filter.
-
-    Returns:
-        String representation of the series.
-    """
-    return (
-        "["
-        + ", ".join(
-            map(
-                lambda x: (
-                    str(int(x))
-                    if isinstance(x, bool)
-                    else (
-                        str(x)
-                        if isinstance(x, (int, float)) and not isnan(x)
-                        else x if isinstance(x, str) else "null"
-                    )
-                ),
-                series,
-            )
-        )
-        + "]"
-    )
-
-
-def generate_html(
-    opts: dict,
-    data: List[Iterable[float, int]],
-) -> str:
-    """Generate plot in an HTML page.
-
-    Returns:
-        HTML contents of the page.
-    """
-    with resources.path("foxplot.uplot", "uPlot.min.css") as path:
-        uplot_min_css = path
-    with resources.path("foxplot.uplot", "uPlot.iife.js") as path:
-        uplot_iife_js = path
-    with resources.path("foxplot.uplot", "uPlot.mousewheel.js") as path:
-        uplot_mwheel_js = path
-
-    color_picker = ColorPicker()
-    right_axis_label = f" {right_axis_unit}" if right_axis_unit else ""
-    left_labels = list(left_axis.keys())
-    right_labels = list(right_axis.keys())
-    labels = left_labels + [r for r in right_labels if r not in left_labels]
-    series_from_label = {}
-    series_from_label.update(left_axis)
-    series_from_label.update(right_axis)
-    html = f"""<!DOCTYPE html>
-<html lang="en">
-    <head>
-        <meta charset="utf-8">
-        <title>{title}</title>
-        <meta name="viewport" content="width=device-width, initial-scale=1">
-        <link rel="stylesheet" href="{uplot_min_css}">
-        <style>
-            div.my-chart {{
-                background-color: white;
-                padding: 10px 0px;  // appear in Right Click -> Take Screenshot
-            }}
-        </style>
-    </head>
-    <body>
-        <script src="{uplot_iife_js}"></script>
-        <script src="{uplot_mwheel_js}"></script>
-        <script>
-            const {{ linear, stepped, bars, spline, spline2 }} = uPlot.paths;
-
-            let data = ["""
-    for label in data.keys():
-        html += f"""
-                {__escape_null(data[label])},"""
-    html += """
-            ];
-
-            const lineInterpolations = {
-                linear: 0,
-                stepAfter: 1,
-                stepBefore: 2,
-                spline: 3,
-            };
-
-            const _stepBefore = stepped({align: -1});
-            const _stepAfter = stepped({align:  1});
-            const _linear = linear();
-            const _spline = spline();
-
-            function paths(u, seriesIdx, idx0, idx1, extendGap, buildClip) {
-                let s = u.series[seriesIdx];
-                let interp = s.lineInterpolation;
-
-                let renderer = (
-                    interp == lineInterpolations.linear ? _linear :
-                    interp == lineInterpolations.stepAfter ? _stepAfter :
-                    interp == lineInterpolations.stepBefore ? _stepBefore :
-                    interp == lineInterpolations.spline ? _spline :
-                    null
-                );
-
-                return renderer(
-                    u, seriesIdx, idx0, idx1, extendGap, buildClip
-                );
-            }
-
-            let opts = {"""
-    html += f"""
-                title: "{title}","""
-    html += """
-                id: "chart1",
-                class: "my-chart",
-                width: window.innerWidth - 20,
-                height: window.innerHeight - 150,
-                cursor: {
-                    drag: {
-                        x: true,
-                        y: true,
-                        uni: 50,
-                    }
-                },
-                plugins: [
-                    wheelZoomPlugin({factor: 0.75})
-                ],"""
-    html += f"""
-                scales: {{
-                    x: {{
-                        time: {"true" if timestamped else "false"},
-                    }},
-                }},
-                series: ["""
-    html += f"""
-                    {{
-                        value: (self, rawValue) => Number.parseFloat(rawValue -
-                        {times[0]}).toPrecision(4),
-                    }},"""
-    for label in labels:
-        html += f"""
-                    {{
-                        // initial toggled state (optional)
-                        show: true,
-                        spanGaps: false,
-
-                        // in-legend display
-                        label: "{label}","""
-        if label in right_labels:
-            html += f"""
-                        value: (self, rawValue) =>
-                            Number.parseFloat(rawValue).toPrecision(2) +
-                            "{right_axis_label}",
-                        scale: "{right_axis_unit}","""
-        else:  # label in left_labels
-            html += f"""
-                        value: (self, rawValue) =>
-                            Number.parseFloat(rawValue).toPrecision(2) +
-                            "{left_axis_label}","""
-        html += f"""
-                        // series style
-                        stroke: "{color_picker.get_next_color()}",
-                        width: 2 / devicePixelRatio,
-                        lineInterpolation: lineInterpolations.stepAfter,
-                        paths,
-                    }},"""
-    html += """
-                ],
-                axes: [
-                    {},
-                    {"""
-    html += f"""
-                        size: {60 + 10 * len({left_axis_label})},
-                        values: (u, vals, space) => vals.map(
-                            v => v + "{left_axis_label}"
-                        ),"""
-    html += """
-                    },
-                    {
-                        side: 1,"""
-    html += f"""
-                        scale: "{right_axis_unit}",
-                        size: {60 + 10 * len({right_axis_label})},
-                        values: (u, vals, space) => vals.map(
-                            v => v + "{right_axis_label}"
-                        ),"""
-    html += """
-                        grid: {show: false},
-                    },
-                ],
-            };
-
-            let uplot = new uPlot(opts, data, document.body);
-
-            // resize with window
-            window.addEventListener("resize", e => {
-                uplot.setSize({
-                    width: window.innerWidth - 20,
-                    height: window.innerHeight - 150,
-                });
-            });
-        </script>
-    </body>
-</html>"""
-    return html

uplot_python-0.0.1/uplot/plot.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-# SPDX-License-Identifier: Apache-2.0
-# Copyright 2024 Inria
-
-"""Main class to manipulate dictionary-series data."""
-
-import logging
-import sys
-import webbrowser
-from typing import BinaryIO, Dict, List, Optional, TextIO, Union
-
-import numpy as np
-from numpy.typing import NDArray
-
-from .generate_html import generate_html
-from .write_tmpfile import write_tmpfile
-
-
-def plot(
-    self,
-    opts: dict,
-    data: List[Iterable[float, int]],
-) -> None:
-    html = generate_html(
-        times,
-        left_series,
-        right_series,
-        title,
-        left_axis_unit,
-        right_axis_unit,
-        timestamped=self.__time is not None,
-    )
-    filename = write_tmpfile(html)
-    webbrowser.open_new_tab(filename)