icplot 0.0.8__tar.gz → 0.0.9__tar.gz

{icplot-0.0.8/src/icplot.egg-info → icplot-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icplot
-Version: 0.0.8
+Version: 0.0.9
 Summary: Utilities for generating plots and graphics for technical reports.
 Author-email: "James Grogan, Irish Centre for High End Computing" <james.grogan@ichec.ie>
 Project-URL: Repository, https://git.ichec.ie/performance/toolshed/icplot
@@ -16,7 +16,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: wand
 Requires-Dist: matplotlib
-Requires-Dist: iccore==0.0.9
+Requires-Dist: iccore==0.0.10
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

{icplot-0.0.8 → icplot-0.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "icplot"
-version = "0.0.8"
+version = "0.0.9"
 authors = [
   { name="James Grogan, Irish Centre for High End Computing", email="james.grogan@ichec.ie" },
 ]
@@ -18,7 +18,7 @@ keywords = ["Publishing", "Technical Reports", "Graphics"]
 
 dependencies = ["wand",
 	       "matplotlib",
-	       "iccore==0.0.9"]
+	       "iccore==0.0.10"]
 
 [project.urls]
 Repository = "https://git.ichec.ie/performance/toolshed/icplot"

icplot-0.0.9/src/icplot/color.py

@@ -0,0 +1,54 @@
+"""
+This module handles colors
+"""
+
+from typing import Callable
+
+from iccore.serialization import Serializable
+
+
+class Color(Serializable):
+    """
+    A color class, internal storage is rgba as float.
+    """
+
+    def __init__(self, r: float = 0.0, g: float = 0.0, b: float = 0.0, a: float = 1.0):
+        self.r = r
+        self.g = g
+        self.b = b
+        self.a = a
+
+    @staticmethod
+    def from_list(data: list):
+        return Color(data[0], data[1], data[2])
+
+    def serialize(self):
+        return {"r": self.r, "g": self.g, "b": self.b, "a": self.a}
+
+    def as_list(self) -> list:
+        return [self.r, self.g, self.b]
+
+    def is_black(self) -> bool:
+        return self.r == 0.0 and self.g == 0.0 and self.b == 0.0 and self.a == 1.0
+
+
+class ColorMap:
+    """
+    A mapping from a flat index to a color
+    """
+
+    def __init__(self, label: str, data_func: Callable):
+        self.label = label
+        self.data_func = data_func
+        self.start_offset = 0.25
+        self.scale = 2
+
+    def get_color(self, cursor: int, values: list) -> Color:
+        """
+        Returns a colour based on a cmap and how far across
+        the datasets you are
+        """
+        position = cursor / len(values)
+        return Color.from_list(
+            self.data_func(self.start_offset + (position / self.scale))
+        )

icplot-0.0.9/src/icplot/graph/__init__.py

@@ -0,0 +1,2 @@
+from .plot import *  # NOQA
+from .series import *  # NOQA

icplot-0.0.9/src/icplot/graph/axis.py

@@ -0,0 +1,44 @@
+"""
+This module has a plot's axis
+"""
+
+from iccore.serialization import Serializable
+
+
+class Range(Serializable):
+    """
+    This is a sequence of numbers specified by lower and upper
+    bounds and a step size. Eg (1, 5, 1) gives: [1, 2, 3, 4]
+    """
+
+    def __init__(self, lower, upper, step):
+        self.lower = lower
+        self.upper = upper
+        self.step = step
+
+    def eval(self) -> list:
+        return list(range(self.lower, self.upper, self.step))
+
+    def serialize(self):
+        return {"lower": self.lower, "upper": self.upper, "step": self.step}
+
+
+class PlotAxis(Serializable):
+    """
+    This is a plot's axis
+    """
+
+    def __init__(self, label: str = ""):
+        self.label = label
+        self.ticks: Range | None = None
+
+    def set_ticks(self, lower: int, upper: int, step: int):
+        self.ticks = Range(lower, upper + 1, step)
+
+    def serialize(self):
+        return {"label": self.label, "ticks": self.ticks.serialize()}
+
+    def get_resolved_ticks(self) -> list:
+        if self.ticks:
+            return self.ticks.eval()
+        return []

icplot-0.0.9/src/icplot/graph/matplotlib.py

@@ -0,0 +1,101 @@
+from pathlib import Path
+import logging
+from typing import cast
+
+logging.getLogger("matplotlib").setLevel(logging.WARNING)
+import matplotlib as mpl  # NOQA
+
+default_backend = mpl.get_backend()
+mpl.use("Agg")
+import matplotlib.pyplot as plt  # NOQA
+
+from icplot.color import ColorMap  # NOQA
+from .series import PlotSeries, LinePlotSeries, ScatterPlotSeries, ImageSeries  # NOQA
+from .plot import Plot, GridPlot  # NOQA
+from .plotter import Plotter  # NOQA
+
+
+class MatplotlibColorMap(ColorMap):
+    """
+    A matplotlib based colormap
+    """
+
+    def __init__(self, label: str):
+        super().__init__(label, mpl.colormaps[label])
+
+
+class MatplotlibPlotter(Plotter):
+    """
+    A plot backend for matplotlib
+    """
+
+    def __init__(self, cmap_label="viridis"):
+        super().__init__(MatplotlibColorMap(cmap_label))
+
+    def set_decorations(self, ax, plot: Plot):
+        ax.legend(loc="upper left")
+        if plot.x_axis.label:
+            ax.set_xlabel(plot.x_axis.label)
+        if plot.y_axis.label:
+            ax.set_ylabel(plot.y_axis.label)
+        if plot.x_axis.ticks:
+            ax.set_xticks(plot.x_axis.get_resolved_ticks())
+        if plot.y_axis.ticks:
+            ax.set_yticks(plot.y_axis.get_resolved_ticks())
+        if plot.title:
+            ax.set_title(plot.title)
+
+    def plot_line(self, ax, series: LinePlotSeries):
+        ax.plot(
+            series.x,
+            series.y,
+            label=series.label,
+            color=series.get_color().as_list(),
+            marker=series.marker,
+        )
+
+    def plot_scatter(self, ax, series: ScatterPlotSeries):
+        ax.scatter(series.data, label=series.label, color=series.get_color().as_list())
+
+    def plot_image(self, ax, series: ImageSeries):
+        ax.imshow(series.data)
+        ax.axis("off")
+
+    def plot_series(self, ax, series: PlotSeries):
+        if series.series_type == "line":
+            self.plot_line(ax, cast(LinePlotSeries, series))
+        elif series.series_type == "scatter":
+            self.plot_scatter(ax, cast(ScatterPlotSeries, series))
+        elif series.series_type == "image":
+            self.plot_image(ax, cast(ImageSeries, series))
+
+    def plot(self, plot: Plot, path: Path | None = None):
+
+        self.apply_cmap_colors(plot)
+
+        fig, ax = plt.subplots()
+
+        self.set_decorations(ax, plot)
+
+        for series in plot.series:
+            self.plot_series(ax, series)
+
+        self.render(fig, path)
+
+    def plot_grid(self, plot: GridPlot, path: Path | None = None, num_samples: int = 0):
+
+        rows, cols, series = plot.get_subplots(num_samples)
+        fig, axs = plt.subplots(rows, cols)
+
+        for ax, series_item in zip(axs, series):
+            self.plot_series(ax, series_item)
+
+        self.render(fig, path)
+
+    def render(self, fig, path: Path | None = None):
+        if path:
+            fig.savefig(path)
+        else:
+            plt.switch_backend(default_backend)
+            fig.show()
+            plt.switch_backend("Agg")

icplot-0.0.9/src/icplot/graph/plot.py

@@ -0,0 +1,92 @@
+"""
+This module has content for generating plots
+"""
+
+import random
+
+from iccore.serialization import Serializable
+
+from .axis import PlotAxis
+from .series import PlotSeries
+
+
+class Plot(Serializable):
+    """
+    A generic plot with optional axis ticks
+    """
+
+    def __init__(
+        self,
+        title: str = "",
+        x_label: str = "",
+        y_label: str = "",
+        legend_label: str = "",
+    ) -> None:
+        self.series: list[PlotSeries] = []
+        self.title = title
+        self.size: tuple | None = None
+        self.plot_type = ""
+        self.x_axis = PlotAxis(x_label)
+        self.y_axis = PlotAxis(y_label)
+        self.legend_label = legend_label
+
+    def set_x_ticks(self, lower, upper, step):
+        self.x_axis.set_ticks(lower, upper, step)
+
+    def set_y_ticks(self, lower, upper, step):
+        self.y_axis.set_ticks(lower, upper, step)
+
+    def add_series(self, series):
+        self.series.append(series)
+
+    def serialize(self):
+        return {
+            "series": [s.serialize() for s in self.series],
+            "title": self.title,
+            "type": self.plot_type,
+            "x_axis": self.x_axis.serialize(),
+            "y_axis": self.y_axis.serialize(),
+            "legend_label": self.legend_label,
+        }
+
+
+class GridPlot(Plot):
+    """
+    Make a grid of plots
+    """
+
+    def __init__(
+        self, data, title: str = "", stride: int = 4, size: tuple = (25, 20)
+    ) -> None:
+        super().__init__(title)
+        self.data = data
+        self.stride = stride
+        self.size = size
+
+    def get_series_indices(self, num_samples: int = 0):
+        rows = num_samples // self.stride
+        cols = num_samples // rows
+        len_data = len(self.data)
+
+        if num_samples == 0:
+            indices = list(range(0, len_data))
+        else:
+            indices = [random.randint(0, len_data - 1) for _ in range(num_samples)]
+        return rows, cols, indices
+
+    def get_subplots(self, num_samples: int = 0):
+        rows, cols, indices = self.get_series_indices(num_samples)
+
+        subplots = []
+        count = 1
+        for index in indices:
+            if num_samples > 0 and count == num_samples + 1:
+                break
+            if isinstance(self.data[index], list):
+                for series in self.data[index]:
+                    subplots.append(series)
+                    count += 1
+            else:
+                subplots.append(self.data[index])
+                count += 1
+        return rows, cols, subplots

icplot-0.0.9/src/icplot/graph/plotter.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+
+from icplot.color import ColorMap
+
+from .plot import Plot
+
+
+class Plotter:
+
+    def __init__(self, cmap: ColorMap):
+        self.cmap = cmap
+
+    def apply_cmap_colors(self, plot: Plot):
+        skipped_color = 0
+        for idx, series in enumerate(plot.series):
+            if not series.color:
+                series.color = self.cmap.get_color(idx - skipped_color, plot.series)
+            else:
+                skipped_color += 1
+
+    def plot(self, plot: Plot, path: Path | None = None):
+        pass

icplot-0.0.9/src/icplot/graph/series.py

@@ -0,0 +1,111 @@
+from iccore.serialization import Serializable
+
+from icplot.color import Color
+
+
+class PlotSeries(Serializable):
+    """
+    A data series in a plot, such as a single line in a line-plot
+    """
+
+    def __init__(self, label: str = "", color: Color | None = None) -> None:
+        self.label = label
+        self.color = color
+        self.series_type = ""
+
+    def get_color(self) -> Color:
+        if self.color:
+            return self.color
+        return Color()
+
+    def serialize(self):
+
+        color_val = {}
+        if self.color:
+            color_val = self.color.serialize()
+
+        return {
+            "label": self.label,
+            "color": color_val,
+            "type": self.series_type,
+        }
+
+
+class ImageSeries(PlotSeries):
+    """
+    A plot data series where the elements are images
+    """
+
+    def __init__(
+        self,
+        data,
+        label: str = "",
+        transform=None,
+    ):
+        super().__init__(label)
+        self.data = data
+        self.series_type = "image"
+        self.transform = transform
+
+    def serialize(self):
+        ret = super().serialize()
+        ret["data"] = self.data
+        return ret
+
+
+class LinePlotSeries(PlotSeries):
+    """
+    A plot series for line plots
+    """
+
+    def __init__(
+        self,
+        x: list | None = None,
+        y: list | None = None,
+        label: str = "",
+        color: Color | None = None,
+        marker: str = "o",
+    ) -> None:
+        super().__init__(label, color)
+        self.marker = marker
+        self.series_type = "line"
+        if x:
+            self.x = x
+        else:
+            self.x = []
+        if y:
+            self.y = y
+        else:
+            self.y = []
+
+    def add_entry(self, x_point: float, y_point: float):
+        self.x.append(x_point)
+        self.y.append(y_point)
+
+    def sort(self):
+        """
+        Sorts by x values
+        """
+        tuples = list(zip(self.x, self.y))
+        tuples.sort(key=lambda tup: tup[0])
+        for idx, _ in enumerate(tuples):
+            self.x[idx] = tuples[idx][0]
+            self.y[idx] = tuples[idx][1]
+
+    def serialize(self):
+        ret = super().serialize()
+        ret["x"] = self.x
+        ret["y"] = self.y
+        return ret
+
+
+class ScatterPlotSeries(PlotSeries):
+    def __init__(self, data, label: str = "", color: Color | None = None):
+        super().__init__(label, color)
+        self.data = data
+        self.series_type = "scatter"
+
+    def serialize(self):
+        ret = super().serialize()
+        ret["data"] = self.data
+        return ret

{icplot-0.0.8 → icplot-0.0.9/src/icplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icplot
-Version: 0.0.8
+Version: 0.0.9
 Summary: Utilities for generating plots and graphics for technical reports.
 Author-email: "James Grogan, Irish Centre for High End Computing" <james.grogan@ichec.ie>
 Project-URL: Repository, https://git.ichec.ie/performance/toolshed/icplot
@@ -16,7 +16,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: wand
 Requires-Dist: matplotlib
-Requires-Dist: iccore==0.0.9
+Requires-Dist: iccore==0.0.10
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

{icplot-0.0.8 → icplot-0.0.9}/src/icplot.egg-info/SOURCES.txt

@@ -18,8 +18,10 @@ src/icplot.egg-info/entry_points.txt
 src/icplot.egg-info/requires.txt
 src/icplot.egg-info/top_level.txt
 src/icplot/graph/__init__.py
-src/icplot/graph/matplotlib_plot_backend.py
+src/icplot/graph/axis.py
+src/icplot/graph/matplotlib.py
 src/icplot/graph/plot.py
+src/icplot/graph/plotter.py
 src/icplot/graph/series.py
 test/test_cairo_interface.py
 test/test_gantt_chart.py

{icplot-0.0.8 → icplot-0.0.9}/src/icplot.egg-info/requires.txt

@@ -1,6 +1,6 @@
 wand
 matplotlib
-iccore==0.0.9
+iccore==0.0.10
 
 [cairo]
 pycairo

{icplot-0.0.8 → icplot-0.0.9}/test/test_line_plots.py

@@ -1,12 +1,16 @@
 from pathlib import Path
 
 from icplot.graph import Plot, LinePlotSeries
+from icplot.graph.matplotlib import MatplotlibPlotter
 
 
 def test_line_plot():
 
     plot = Plot(
-        title="test", x_label="test_x", y_label="test_y", legend_label="test_legend"
+        title="test",
+        x_label="test_x",
+        y_label="test_y",
+        legend_label="test_legend"
     )
 
     data = [([0, 5, 10], [1, 2, 3]), ([0, 5, 10], [3, 6, 9]), ([0, 5, 10], [4, 8, 12])]
@@ -17,7 +21,9 @@ def test_line_plot():
     plot.set_x_ticks(0, 10, 5)
 
     output_path = Path() / "output.svg"
-    plot.plot(output_path)
+
+    plotter = MatplotlibPlotter()
+    plotter.plot(plot, output_path)
 
     assert output_path.exists()
     output_path.unlink()

icplot-0.0.8/src/icplot/color.py

@@ -1,13 +0,0 @@
-class Color:
-
-    def __init__(self, r=1, g=1, b=1, a=1):
-        self.r = r
-        self.g = g
-        self.b = b
-        self.a = a
-
-
-class ColorMap:
-
-    def __init__(self, label: str):
-        self.label = label

icplot-0.0.8/src/icplot/graph/__init__.py

@@ -1 +0,0 @@
-from .plot import *  # NOQA

icplot-0.0.8/src/icplot/graph/matplotlib_plot_backend.py

@@ -1,69 +0,0 @@
-from pathlib import Path
-import logging
-
-logging.getLogger("matplotlib").setLevel(logging.WARNING)
-import matplotlib  # NOQA
-
-default_backend = matplotlib.get_backend()
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt  # NOQA
-import matplotlib as mpl  # NOQA
-
-from icplot.color import ColorMap  # NOQA
-
-
-class MatplotlibColorMap(ColorMap):
-
-    def __init__(self, label: str):
-        super().__init__(label)
-        self.c_map = mpl.colormaps[label]
-        self.cmap_start_offset = 0.25
-        self.cmap_scale = 2
-
-    def get_color(self, cursor: int, values: list):
-        """
-        Returns a colour based on a cmap and how far across
-        the datasets you are
-        """
-        position = cursor / len(values)
-        return self.c_map(self.cmap_start_offset + (position / self.cmap_scale))
-
-
-class MatplotlibPlotBackend:
-
-    def __init__(self):
-        self.ax = plt.subplot(111)
-
-    def set_decorations(self, x_label, y_label, title, x_ticks, y_ticks):
-        self.ax.legend(loc="upper left")
-        if x_label:
-            self.ax.set_xlabel(x_label)
-        if y_label:
-            self.ax.set_ylabel(y_label)
-        if title:
-            self.ax.set_title(title)
-        if x_ticks:
-            self.ax.set_xticks(x_ticks)
-        if y_ticks:
-            self.ax.set_yticks(y_ticks)
-
-    def plot_line(self, x, y, label, color):
-        self.ax.plot(x, y, label=label, color=color)
-
-    def plot_scatter(self, data, label, color):
-        self.ax.plot(data, label=label, color=color)
-
-    def make_subplot(self, rows, cols, count):
-        plt.subplot(rows, cols, count)
-
-    def plot_image(self, data):
-        plt.imshow(data)
-        plt.axis("off")
-
-    def render(self, path: Path | None = None):
-        if path:
-            plt.savefig(path)
-        else:
-            plt.switch_backend(default_backend)
-            plt.show()
-            plt.switch_backend("Agg")

icplot-0.0.8/src/icplot/graph/plot.py

@@ -1,163 +0,0 @@
-"""
-This module has content for generating plots
-"""
-
-import random
-from pathlib import Path
-from typing import cast
-import json
-
-from .series import PlotSeries, LinePlotSeries, ScatterPlotSeries, ImageSeries
-from .matplotlib_plot_backend import MatplotlibPlotBackend, MatplotlibColorMap
-
-
-class Range:
-
-    def __init__(self, lower, upper, step):
-        self.lower = lower
-        self.upper = upper
-        self.step = step
-
-    def eval(self):
-        return range(self.lower, self.upper, self.step)
-
-    def serialize(self):
-        return {"lower": self.lower, "upper": self.upper, "step": self.step}
-
-    def __str__(self):
-        return json.dumps(self.serialize(), ident=4)
-
-
-class Plot:
-    """
-    A generic plot with optional axis ticks
-    """
-
-    def __init__(
-        self,
-        title: str = "",
-        x_label: str = "",
-        y_label: str = "",
-        legend_label: str = "",
-    ) -> None:
-        self.series: list[PlotSeries] = []
-        self.title = title
-        self.size: tuple | None = None
-        self.plot_type = ""
-        self.x_label = x_label
-        self.y_label = y_label
-        self.legend_label = legend_label
-        self.x_ticks: Range | None = None
-        self.y_ticks: Range | None = None
-        self.backend = MatplotlibPlotBackend()
-        self.cmap = MatplotlibColorMap("viridis")
-
-    def set_colour_map(self, cmap):
-        self.c_map = MatplotlibColorMap(cmap)
-
-    def set_x_ticks(self, lower, upper, step):
-        self.x_ticks = Range(lower, upper + 1, step)
-
-    def set_y_ticks(self, lower, upper, step):
-        self.y_ticks = Range(lower, upper + 1, step)
-
-    def set_decorations(self):
-
-        xtick_range = None
-        ytick_range = None
-        if self.x_ticks:
-            xtick_range = self.x_ticks.eval()
-        if self.y_ticks:
-            ytick_range = self.y_ticks.eval()
-
-        self.backend.set_decorations(
-            self.x_label,
-            self.y_label,
-            self.title,
-            xtick_range,
-            ytick_range,
-        )
-
-    def add_series(self, series):
-        self.series.append(series)
-
-    def plot_series(self, series, label):
-        if series.series_type == "line":
-            line_series = cast(LinePlotSeries, series)
-            self.backend.plot_line(
-                line_series.x, line_series.y, label=label, color=series.color
-            )
-        elif series.series_type == "scatter":
-            scatter_series = cast(ScatterPlotSeries, series)
-            self.backend.plot_scatter(
-                scatter_series.data, label=label, color=series.color
-            )
-        elif series.series_type == "image":
-            image_series = cast(ImageSeries, series)
-            self.backend.plot_image(image_series.data)
-
-    def plot(self, path: Path | None = None):
-        for idx, series in enumerate(self.series):
-            series.color = self.cmap.get_color(idx, self.series)
-
-        first = True
-        for series in self.series:
-            label = series.label
-            if first and self.legend_label:
-                label = f"{label} {self.legend_label}"
-                first = False
-            self.plot_series(series, label)
-
-        self.set_decorations()
-        self.backend.render(path)
-
-    def serialize(self):
-        return {
-            "series": [s.serialize() for s in self.series],
-            "title": self.title,
-            "type": self.plot_type,
-            "xlabel": self.x_label,
-            "ylabel": self.y_label,
-            "legend_label": self.legend_label,
-            "xticks": self.x_ticks.serialize(),
-            "yticks": self.y_ticks.serialize(),
-        }
-
-
-class GridPlot(Plot):
-    """
-    Make a grid of plots
-    """
-
-    def __init__(
-        self, title: str = "", stride: int = 4, size: tuple = (25, 20)
-    ) -> None:
-        super().__init__(title)
-        self.stride = stride
-        self.size = size
-
-    def _subplot(self, rows: int, cols: int, count: int, series):
-
-        self.backend.make_subplot(rows, cols, count)
-        self.plot_series(series, "")
-        return count + 1
-
-    def render(self, data, path: Path, num_samples: int = 0):
-        rows = num_samples // self.stride
-        cols = num_samples // rows
-        count = 1
-        if num_samples == 0:
-            indices = [random.randint(0, len(data) - 1) for _ in range(num_samples)]
-        else:
-            indices = list(range(0, len(data)))
-
-        for index in indices:
-            if num_samples > 0 and count == num_samples + 1:
-                break
-            if isinstance(data[index], list):
-                for series in data[index]:
-                    count = self._subplot(rows, cols, count, series)
-            else:
-                count = self._subplot(rows, cols, count, data[index])
-
-        self.backend.render(path)

icplot-0.0.8/src/icplot/graph/series.py

@@ -1,54 +0,0 @@
-import json
-
-
-class PlotSeries:
-
-    def __init__(self, label: str = ""):
-        self.label = label
-        self.color: list[float] = [0.0, 0.0, 0.0]
-        self.series_type = ""
-
-    def serialize(self):
-        return {"label": self.label, "color": self.color, "type": self.series_type}
-
-    def __str__(self):
-        return json.dumps(self.serialize(), indent=4)
-
-
-class ImageSeries(PlotSeries):
-    def __init__(self, data, label: str = "", transform=None):
-        super().__init__(label)
-        self.data = data
-        self.series_type = "image"
-        self.transform = transform
-
-    def serialize(self):
-        ret = super().serialize()
-        ret["data"] = self.data
-        return ret
-
-
-class LinePlotSeries(PlotSeries):
-    def __init__(self, x: list[float], y: list[float], label: str = "") -> None:
-        super().__init__(label)
-        self.series_type = "line"
-        self.x = x
-        self.y = y
-
-    def serialize(self):
-        ret = super().serialize()
-        ret["x"] = self.x
-        ret["y"] = self.y
-        return ret
-
-
-class ScatterPlotSeries(PlotSeries):
-    def __init__(self, data, label: str = ""):
-        super().__init__(label)
-        self.data = data
-        self.series_type = "scatter"
-
-    def serialize(self):
-        ret = super().serialize()
-        ret["data"] = self.data
-        return ret