icplot 0.0.8__tar.gz → 0.0.10__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icplot
-Version: 0.0.8
+Version: 0.0.10
 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.1.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

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

@@ -1,6 +1,6 @@
 [project]
 name = "icplot"
-version = "0.0.8"
+version = "0.0.10"
 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.1.0"]
 
 [project.urls]
 Repository = "https://git.ichec.ie/performance/toolshed/icplot"

{icplot-0.0.8 → icplot-0.0.10}/src/icplot/cairo_interface.py

@@ -1,8 +1,8 @@
-import os
 from pathlib import Path
+
 import cairo
 
-from .geometry import Scene, Rectangle, Color, TextPath
+from .geometry import Scene, Rectangle
 
 
 class CairoInterface:
@@ -52,29 +52,9 @@ class CairoInterface:
             if item.item_type == "shape":
                 self.draw_shape(cr, item)
             elif item.item_type == "text":
-                self.draw_text(cr, text)
+                self.draw_text(cr, item)
 
-    def draw_svg(self, scene, path):
+    def draw_svg(self, scene: Scene, path: Path):
         with cairo.SVGSurface(path, scene.size[0], scene.size[1]) as surface:
             cr = cairo.Context(surface)
             self.draw_scene(cr, scene)
-
-
-if __name__ == "__main__":
-
-    cairo_interface = CairoInterface()
-
-    scene = Scene()
-
-    rect = Rectangle(20, 20)
-    rect.location = (10, 10)
-    rect.fill = Color(0.5, 0.5, 1, 0.5)
-    rect.stroke = Color(0.5, 0.0, 0.0, 0.5)
-    scene.items.append(rect)
-
-    text = TextPath("Hello World")
-    text.location = (5, 5)
-    scene.items.append(text)
-
-    output_path = Path(os.getcwd()) / "output.svg"
-    cairo_interface.draw_svg(scene, output_path)

icplot-0.0.10/src/icplot/color.py

@@ -0,0 +1,56 @@
+"""
+This module handles colors
+"""
+
+from typing import Callable
+
+from pydantic import BaseModel
+
+
+class Color(BaseModel):
+    """
+    A color class, internal storage is rgba as float.
+    """
+
+    r: float = 0.0
+    g: float = 0.0
+    b: float = 0.0
+    a: float = 1.0
+
+    @staticmethod
+    def from_rgba(r: float = 0.0, b: float = 0.0, g: float = 0.0, a: float = 1.0):
+        return Color(**{"r": r, "g": g, "b": b, "a": a})
+
+    @staticmethod
+    def from_list(data: list):
+        return Color(**{"r": data[0], "g": data[1], "b": data[2]})
+
+    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
+
+    def serialize(self) -> str:
+        return f"r: {self.r}, g: {self.g}, b: {self.b}, a: {self.a}"
+
+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.10/src/icplot/gantt/__init__.py

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

icplot-0.0.10/src/icplot/gantt/gantt.py

@@ -0,0 +1,19 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from iccore.project import Milestone
+
+from icplot.color import Color
+
+
+class GanttChart(BaseModel):
+
+    milestones: list[Milestone] = []
+    title: str = ""
+    start_date: datetime | None = None
+    end_date: datetime | None = None
+    bar_max_height: float = 0.1
+    height: int = 100
+    width: int = 500
+    bar_color: Color = Color.from_rgba(0.7, 0, 0)

icplot-0.0.10/src/icplot/gantt/gantt_renderer.py

@@ -0,0 +1,59 @@
+from iccore.project import Milestone
+from icplot.geometry import Scene, Rectangle
+
+from .gantt import GanttChart
+
+
+class GanttRenderer:
+
+    def _add_milestone(
+        self, gantt: GanttChart, scene: Scene, milestone: Milestone, chart_range, yloc
+    ):
+        # chart_delta = chart_range[1] - chart_range[0]
+        chart_delta = 0
+        start_delta = milestone.start_date - chart_range[0]
+        # milestone_delta = milestone.due_date - milestone.start_date
+        milestone_delta = 0
+
+        start_frac = float(start_delta / chart_delta)
+        milestone_frac = float(milestone_delta / chart_delta)
+
+        w = milestone_frac * gantt.width
+        h = gantt.bar_max_height * gantt.height
+        x = start_frac * gantt.width
+        y = yloc
+
+        rect = Rectangle(w, h)
+        rect.location = (x, y)
+        rect.fill = gantt.bar_color
+        scene.items.append(rect)
+
+    def _add_milestones(self, gantt: GanttChart, scene: Scene):
+
+        if not gantt.milestones:
+            return
+
+        milestones = gantt.milestones
+        # milestones.sort(key=lambda x: x.start_date, reverse=True)
+
+        start_date = gantt.start_date
+        end_date = gantt.end_date
+        if not start_date:
+            start_date = milestones[0].start_date
+
+        # if not end_date:
+        #    end_date = max(m.due_date for m in milestones)
+
+        chart_range = (start_date, end_date)
+        yloc = 0.0
+        bar_height = gantt.bar_max_height * gantt.height
+        for milestone in milestones:
+            self._add_milestone(gantt, scene, milestone, chart_range, yloc)
+            yloc += bar_height
+
+    def render(self, gantt: GanttChart) -> Scene:
+        scene = Scene()
+
+        self._add_milestones(gantt, scene)
+
+        return scene

icplot-0.0.10/src/icplot/gantt/pgfgantt_interface.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+from .gantt import GanttChart
+
+
+class PgfGanttRenderer:
+
+    def __init__(self):
+        self.template: str = ""
+
+    def _load_template(self):
+        if self.template:
+            return
+
+        with open(Path(__file__).parent / "pgfgantt.tex", "r", encoding="utf-8") as f:
+            self.template = f.read()
+
+    def render(self, gantt: GanttChart) -> str:
+
+        output = self.template
+
+        if gantt.title:
+            title_str = f"\\title{{{gantt.title}}}"
+            output.replace("%%TITLE%%", title_str)
+
+        return output

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

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

icplot-0.0.10/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.10/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()
+
+        for series in plot.series:
+            self.plot_series(ax, series)
+
+        self.set_decorations(ax, plot)
+
+        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.10/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.10/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.10/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.10}/src/icplot/image_utils.py

@@ -1,3 +1,8 @@
+"""
+This module has functions for converting between image
+formats
+"""
+
 import logging
 from pathlib import Path
 
@@ -12,14 +17,16 @@ logger = logging.getLogger(__name__)
 def _get_out_filename(source: Path, target: Path | None, extension: str) -> Path:
     if target:
         return target
-    else:
-        return source.parent / f"{source.stem}.{extension}"
+    return source.parent / f"{source.stem}.{extension}"
 
 
-def pdf_to_png(source: Path, target: Path | None = None):
+def pdf_to_png(source: Path, target: Path | None = None, resolution: int = 300):
+    """
+    Convert a pdf to png with white background
+    """
 
     outfile = _get_out_filename(source, target, "png")
-    with Image(filename=source, resolution=300) as img:
+    with Image(filename=source, resolution=resolution) as img:
         img.format = "png"
         img.background_color = Color("white")
         img.alpha_channel = "remove"
@@ -27,10 +34,18 @@ def pdf_to_png(source: Path, target: Path | None = None):
 
 
 def svg_to_png(source: Path, target: Path | None = None):
+    """
+    Convert an svg to png
+    """
+
     outfile = _get_out_filename(source, target, "png")
     cairosvg.svg2png(url=str(source), write_to=str(outfile))
 
 
 def svg_to_pdf(source: Path, target: Path | None = None):
+    """
+    Convert an svg to pdf
+    """
+
     outfile = _get_out_filename(source, target, "pdf")
     cairosvg.svg2pdf(url=str(source), write_to=str(outfile))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icplot
-Version: 0.0.8
+Version: 0.0.10
 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.1.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

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

@@ -5,11 +5,10 @@ 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
 src/icplot/main_cli.py
-src/icplot/project_elements.py
+src/icplot/py.typed
 src/icplot/tex_interface.py
 src/icplot.egg-info/PKG-INFO
 src/icplot.egg-info/SOURCES.txt
@@ -17,9 +16,15 @@ src/icplot.egg-info/dependency_links.txt
 src/icplot.egg-info/entry_points.txt
 src/icplot.egg-info/requires.txt
 src/icplot.egg-info/top_level.txt
+src/icplot/gantt/__init__.py
+src/icplot/gantt/gantt.py
+src/icplot/gantt/gantt_renderer.py
+src/icplot/gantt/pgfgantt_interface.py
 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.10}/src/icplot.egg-info/requires.txt

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

icplot-0.0.10/test/test_cairo_interface.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+import os
+import shutil
+
+from icplot.cairo_interface import CairoInterface
+from icplot.geometry import Scene, Rectangle, TextPath
+from icplot.color import Color
+
+
+def test_cairo_interface():
+
+    cairo_interface = CairoInterface()
+    scene = Scene()
+
+    rect = Rectangle(20, 20)
+    rect.location = (10, 10)
+    rect.fill = Color.from_rgba(0.5, 0.5, 1, 0.5)
+    rect.stroke = Color.from_rgba(0.5, 0.0, 0.0, 0.5)
+    scene.items.append(rect)
+
+    text = TextPath("Hello World")
+    text.location = (5, 5)
+    scene.items.append(text)
+
+    output_dir = Path(os.getcwd()) / "test_cairo_interface"
+    os.makedirs(output_dir, exist_ok=True)
+    cairo_interface.draw_svg(scene, output_dir / "output.svg")
+    shutil.rmtree(output_dir)
+    

{icplot-0.0.8 → icplot-0.0.10}/test/test_gantt_chart.py

@@ -24,8 +24,3 @@ def test_gantt_chart():
     gantt = GanttChart()
     gantt.milestones = [milestone0, milestone1]
 
-    output_path = Path(os.getcwd()) / "gantt.svg"
-
-    gantt.plot(output_path)
-
-    output_path.unlink()

{icplot-0.0.8 → icplot-0.0.10}/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/gantt.py

@@ -1,64 +0,0 @@
-from pathlib import Path
-from .cairo_interface import CairoInterface
-from .geometry import Scene, Color, Rectangle
-
-
-class GanttChart:
-
-    def __init__(self):
-        self.milestones = []
-        self.start_date = None
-        self.end_date = None
-        self.milestone_bar_max_height = 0.1
-        self.height = 100
-        self.width = 500
-        self.milestone_color = Color(0.7, 0, 0)
-
-    def _add_milestone(self, scene, milestone, chart_range, yloc):
-        chart_delta = chart_range[1] - chart_range[0]
-        start_delta = milestone.start_date - chart_range[0]
-        milestone_delta = milestone.due_date - milestone.start_date
-
-        start_frac = float(start_delta / chart_delta)
-        milestone_frac = float(milestone_delta / chart_delta)
-
-        w = milestone_frac * self.width
-        h = self.milestone_bar_max_height * self.height
-        x = start_frac * self.width
-        y = yloc
-
-        rect = Rectangle(w, h)
-        rect.location = (x, y)
-        rect.fill = self.milestone_color
-        scene.items.append(rect)
-
-    def _add_milestones(self, scene):
-
-        if not self.milestones:
-            return
-
-        milestones = self.milestones
-        milestones.sort(key=lambda x: x.start_date, reverse=True)
-
-        start_date = self.start_date
-        end_date = self.end_date
-        if not start_date:
-            start_date = milestones[0].start_date
-
-        if not end_date:
-            end_date = max(m.due_date for m in milestones)
-
-        chart_range = (start_date, end_date)
-        yloc = 0
-        bar_height = self.milestone_bar_max_height * self.height
-        for milestone in milestones:
-            self._add_milestone(scene, milestone, chart_range, yloc)
-            yloc += bar_height
-
-    def plot(self, path: Path):
-        scene = Scene()
-
-        self._add_milestones(scene)
-
-        renderer = CairoInterface()
-        renderer.draw_svg(scene, path)

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

icplot-0.0.8/src/icplot/project_elements.py

@@ -1,4 +0,0 @@
-class GitlabUser:
-
-    def __init__(self):
-        self.name = ""

icplot-0.0.8/test/test_cairo_interface.py

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