icplot 0.0.7__tar.gz → 0.0.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icplot
-Version: 0.0.7
+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.7 → icplot-0.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "icplot"
-version = "0.0.7"
+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.7 → icplot-0.0.9}/src/icplot/geometry.py

@@ -1,10 +1,4 @@
-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
+from .color import Color
 
 
 class Font:

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.7 → icplot-0.0.9/src/icplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icplot
-Version: 0.0.7
+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.7 → icplot-0.0.9}/src/icplot.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 setup.cfg
 src/icplot/__init__.py
 src/icplot/cairo_interface.py
+src/icplot/color.py
 src/icplot/gantt.py
 src/icplot/geometry.py
 src/icplot/image_utils.py
@@ -17,7 +18,11 @@ 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/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
 test/test_image_utils.py

{icplot-0.0.7 → 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.7 → icplot-0.0.9}/test/test_cairo_interface.py

@@ -1,5 +1,6 @@
 from icplot.cairo_interface import CairoInterface
 
+
 def test_cairo_interface():
 
     cairo_interface = CairoInterface()

{icplot-0.0.7 → icplot-0.0.9}/test/test_gantt_chart.py

@@ -20,10 +20,9 @@ def test_gantt_chart():
     milestone1.description = "Description of Milestone 1."
     milestone1.start_date = datetime.date(2024, 7, 1)
     milestone1.due_date = datetime.date(2024, 7, 15)
-    
+
     gantt = GanttChart()
-    gantt.milestones = [milestone0,
-                        milestone1]
+    gantt.milestones = [milestone0, milestone1]
 
     output_path = Path(os.getcwd()) / "gantt.svg"
 

{icplot-0.0.7 → icplot-0.0.9}/test/test_image_utils.py

@@ -3,9 +3,11 @@ from pathlib import Path
 
 from icplot.image_utils import svg_to_png, svg_to_pdf
 
+
 def get_test_data_dir():
     return Path(__file__).parent / "data"
-    
+
+
 def test_convert_svg():
 
     source = get_test_data_dir() / "test.svg"
@@ -17,5 +19,3 @@ def test_convert_svg():
     pdf_out = Path(os.getcwd()) / "out.pdf"
     svg_to_pdf(source, pdf_out)
     pdf_out.unlink()
-
-    

icplot-0.0.9/test/test_line_plots.py

@@ -0,0 +1,29 @@
+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"
+    )
+
+    data = [([0, 5, 10], [1, 2, 3]), ([0, 5, 10], [3, 6, 9]), ([0, 5, 10], [4, 8, 12])]
+
+    for idx, [x, y] in enumerate(data):
+        plot.add_series(LinePlotSeries(x, y, label=f"Series {idx}"))
+
+    plot.set_x_ticks(0, 10, 5)
+
+    output_path = Path() / "output.svg"
+
+    plotter = MatplotlibPlotter()
+    plotter.plot(plot, output_path)
+
+    assert output_path.exists()
+    output_path.unlink()

{icplot-0.0.7 → icplot-0.0.9}/test/test_tex_interface.py

@@ -3,6 +3,7 @@ import shutil
 from pathlib import Path
 from icplot.tex_interface import TexInterface
 
+
 def test_tex_interface():
 
     build_dir = Path(os.getcwd()) / "tmp_build"

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

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

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

@@ -1,200 +0,0 @@
-"""
-This module has content for generating plots
-"""
-
-import random
-from pathlib import Path
-from typing import cast
-
-import logging
-
-logging.getLogger("matplotlib").setLevel(logging.WARNING)
-import matplotlib  # NOQA
-
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt  # NOQA
-import matplotlib as mpl  # NOQA
-
-
-class PlotSeries:
-
-    def __init__(self, label: str = ""):
-        self.label = label
-
-
-class LinePlotSeries(PlotSeries):
-    def __init__(self, x: list[float], y: list[float], label: str = "") -> None:
-        super().__init__(label)
-        self.x = x
-        self.y = y
-
-
-class MatplotlibPlotter:
-
-    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 render(self, path: Path | None = None):
-        if path:
-            plt.savefig(path)
-        else:
-            plt.show()
-
-
-class Plot:
-    def __init__(
-        self,
-        title: str = "",
-        x_label: str = "",
-        y_label: str = "",
-        legend_label: str = "",
-    ) -> None:
-        self.series: list[PlotSeries] = []
-        self.title = title
-        self.plot_type = ""
-        self.x_label = x_label
-        self.y_label = y_label
-        self.legend_label = legend_label
-        self.c_map = mpl.colormaps["viridis"]
-        self.x_ticks = None
-        self.y_ticks = None
-        self.impl = MatplotlibPlotter()
-
-    def get_colour(self, curr, values, c_map):
-        """
-        Returns a colour based on a cmap and how far across
-        the datasets you are
-        """
-        length = len(values)
-        position = curr / length
-        return c_map(0.25 + (position / 2))
-
-    def set_colour_map(self, cmap="viridis"):
-        self.c_map = mpl.colormaps[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):
-        self.impl.set_decorations(
-            self.x_label, self.y_label, self.title, self.x_ticks, self.y_ticks
-        )
-
-    def plot(self, path: Path | None = None):
-        raise NotImplementedError()
-
-
-class LinePlot(Plot):
-
-    def plot(self, path: Path | None = None):
-
-        first = True
-        for i, series in enumerate(self.series):
-            colour = self.get_colour(i, self.series, self.c_map)
-            label = f"{series.label}"
-            if first and self.legend_label:
-                label = f"{label} {self.legend_label}"
-                first = False
-            line_series = cast(LinePlotSeries, series)
-            self.impl.plot_line(line_series.x, line_series.y, label=label, color=colour)
-
-        self.set_decorations()
-        self.impl.render(path)
-
-
-class MultiFigureLinePlotter:
-    """
-    Plot with multiple figures. Each is a line plot
-    """
-
-    def __init__(self, data: dict, figures: list, xlabel: str) -> None:
-        self.data = data
-        self.figures = figures
-        self.size: tuple = (10, 5)
-        self.xlabel = xlabel
-        self.output_fmt = "svg"
-
-    def _plot_line(self, key: str, label: str):
-        plt.plot(self.data[key], label=label)
-
-    def _decorate(self, ylabel: str, title: str):
-        plt.title(title)
-        plt.xlabel(self.xlabel)
-        plt.ylabel(ylabel)
-        plt.legend()
-        plt.show()
-
-    def plot(self, output_path: Path):
-        """
-        Do the plot
-        """
-
-        for idx, figure_info in enumerate(self.figures):
-            plt.figure(figsize=self.size)
-
-            for data_key, label in zip(figure_info["keys"], figure_info["labels"]):
-                self._plot_line(data_key, label)
-
-            title = figure_info["title"]
-            ylabel = figure_info["ylabel"]
-
-            self._decorate(ylabel, title)
-            plt.savefig(str(output_path) + f"_{idx}.{self.output_fmt}")
-
-
-class DatasetGridPlotter:
-    """
-    Plot a dataset on a grid. A dataset has pairs of images corresponding
-    to an image and an associated mask.
-    """
-
-    def __init__(
-        self, title: str = "", stride: int = 4, size: tuple = (25, 20)
-    ) -> None:
-        self.title = title
-        self.stride = stride
-        self.size = size
-
-    def _plot_grid_element(self, rows: int, cols: int, count: int, image, transform):
-        plt.subplot(rows, cols, count)
-        if transform:
-            plt.imshow(transform.reverse(image.squeeze(0).float()))
-        else:
-            plt.imshow(image.squeeze(0).float())
-        plt.axis("off")
-        plt.title(self.title)
-        return count + 1
-
-    def plot(self, data, num_samples: int, output_path: Path, transform=None):
-        plt.figure(figsize=self.size)
-        rows = num_samples // self.stride
-        cols = num_samples // rows
-        count = 1
-        indices = [random.randint(0, len(data) - 1) for _ in range(num_samples)]
-
-        for index in indices:
-            if count == num_samples + 1:
-                break
-            x, y = data[index]
-            count = self._plot_grid_element(rows, cols, count, x, transform)
-            count = self._plot_grid_element(rows, cols, count, y, transform)
-        plt.savefig(output_path)

icplot-0.0.7/test/test_line_plots.py

@@ -1,26 +0,0 @@
-from pathlib import Path
-
-from icplot.graph import LinePlot, LinePlotSeries
-
-
-def test_line_plot():
-    
-    plot = LinePlot(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])]
-
-    for idx, [x, y] in enumerate(data):
-        plot.series.append(LinePlotSeries(x, y,  label=f"Series {idx}"))
-        
-    plot.set_x_ticks(0, 10, 5)
-
-    output_path = Path() / "output.svg"
-    plot.plot(output_path)
-
-    assert output_path.exists()
-    output_path.unlink()