icplot 0.0.10__tar.gz → 0.0.11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icplot
-Version: 0.0.10
+Version: 0.0.11
 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.1.0
+Requires-Dist: iccore==0.1.1
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
@@ -62,6 +62,12 @@ To covert between image formats you can do:
 icplot convert --source my_image.svg --target my_image.png
 ```
 
+To render a Tex tikz image as pdf and png you can do:
+
+``` shell
+icplot convert --source my_tikz.tex
+```
+
 # Copyright #
 
 Copyright 2024 Irish Centre for High End Computing

{icplot-0.0.10 → icplot-0.0.11}/README.md

@@ -31,6 +31,12 @@ To covert between image formats you can do:
 icplot convert --source my_image.svg --target my_image.png
 ```
 
+To render a Tex tikz image as pdf and png you can do:
+
+``` shell
+icplot convert --source my_tikz.tex
+```
+
 # Copyright #
 
 Copyright 2024 Irish Centre for High End Computing

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

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

{icplot-0.0.10 → icplot-0.0.11}/src/icplot/color.py

@@ -34,6 +34,7 @@ class Color(BaseModel):
     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
@@ -42,15 +43,11 @@ class ColorMap:
     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))
-        )
+        position = cursor / (len(values) - 1)
+        return Color.from_list(self.data_func(position))

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

@@ -0,0 +1,33 @@
+"""
+This module has a plot's axis
+"""
+
+from pydantic import BaseModel
+
+
+class Range(BaseModel):
+    """
+    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]
+    """
+
+    lower: int
+    upper: int
+    step: int
+
+    def eval(self) -> list:
+        return list(range(self.lower, self.upper, self.step))
+
+
+class PlotAxis(BaseModel):
+    """
+    This is a plot's axis
+    """
+
+    label: str = ""
+    ticks: Range | None = None
+
+    def get_resolved_ticks(self) -> list:
+        if self.ticks:
+            return self.ticks.eval()
+        return []

{icplot-0.0.10 → icplot-0.0.11}/src/icplot/graph/matplotlib.py

@@ -29,7 +29,7 @@ class MatplotlibPlotter(Plotter):
     A plot backend for matplotlib
     """
 
-    def __init__(self, cmap_label="viridis"):
+    def __init__(self, cmap_label="gist_rainbow"):
         super().__init__(MatplotlibColorMap(cmap_label))
 
     def set_decorations(self, ax, plot: Plot):
@@ -50,12 +50,12 @@ class MatplotlibPlotter(Plotter):
             series.x,
             series.y,
             label=series.label,
-            color=series.get_color().as_list(),
+            color=series.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())
+        ax.scatter(series.data, label=series.label, color=series.color.as_list())
 
     def plot_image(self, ax, series: ImageSeries):
         ax.imshow(series.data)

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

@@ -0,0 +1,64 @@
+"""
+This module has content for generating plots
+"""
+
+import random
+
+from pydantic import BaseModel
+
+from .axis import PlotAxis
+from .series import PlotSeries
+
+
+class Plot(BaseModel):
+    """
+    A generic plot with optional axis ticks
+    """
+
+    title: str = ""
+    legend_label: str = ""
+    x_axis: PlotAxis = PlotAxis()
+    y_axis: PlotAxis = PlotAxis()
+    plot_type: str = ""
+    series: list[PlotSeries] = []
+
+    def add_series(self, series: PlotSeries):
+        self.series.append(series)
+
+
+class GridPlot(Plot):
+    """
+    Make a grid of plots
+    """
+
+    stride: int = 4
+    size: tuple = (25, 20)
+    data: list = []
+
+    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 → icplot-0.0.11}/src/icplot/graph/plotter.py

@@ -11,12 +11,13 @@ class Plotter:
         self.cmap = cmap
 
     def apply_cmap_colors(self, plot: Plot):
-        skipped_color = 0
+        non_highlight = []
         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
+            if not series.highlight:
+                non_highlight.append(series)
+
+        for idx, series in enumerate(non_highlight):
+            series.color = self.cmap.get_color(idx, non_highlight)
 
     def plot(self, plot: Plot, path: Path | None = None):
         pass

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

@@ -0,0 +1,43 @@
+import typing
+
+from pydantic import BaseModel
+
+from icplot.color import Color
+
+
+class PlotSeries(BaseModel):
+    """
+    A data series in a plot, such as a single line in a line-plot
+    """
+
+    label: str
+    color: Color = Color()
+    series_type: str = ""
+    highlight: bool = False
+
+
+class ImageSeries(PlotSeries):
+    """
+    A plot data series where the elements are images
+    """
+
+    data: typing.Any
+    transform: typing.Any
+    series_type: str = "image"
+
+
+class LinePlotSeries(PlotSeries):
+    """
+    A plot series for line plots
+    """
+
+    x: list
+    y: list
+    marker: str = "o"
+    series_type: str = "line"
+
+
+class ScatterPlotSeries(PlotSeries):
+
+    data: typing.Any
+    series_type: str = "scatter"

{icplot-0.0.10 → icplot-0.0.11}/src/icplot/main_cli.py

@@ -2,24 +2,23 @@
 import argparse
 import logging
 from pathlib import Path
+import os
 
-from iccore import logging_utils
-from iccore import runtime
+from iccore.cli_utils import launch_common
+from iccore.serialization import read_yaml
 
+from icplot.graph import Plot
+from icplot.graph.matplotlib import MatplotlibPlotter
 from icplot.image_utils import pdf_to_png, svg_to_png, svg_to_pdf
+from icplot.tex_interface import TexBuildSettings, TexInterface
 
 logger = logging.getLogger(__name__)
 
 
-def launch_common(args):
-    runtime.ctx.set_is_dry_run(args.dry_run)
-    logging_utils.setup_default_logger()
-
-
 def convert(args):
     launch_common(args)
 
-    logger.info("Attempting coversion between %s %s", args.source, args.target)
+    logger.info("Startubg conversion between %s and %s", args.source, args.target)
 
     if args.target:
         target = Path(args.target).resolve()
@@ -36,9 +35,35 @@ def convert(args):
                 svg_to_pdf(args.source.resolve(), target)
         else:
             svg_to_png(args.source)
+    elif args.source.suffix == ".tex":
+        if args.target:
+            target = Path(args.target).resolve()
+        else:
+            target = Path(os.getcwd())
+
+        settings = TexBuildSettings(
+            args.source.resolve(), args.build_dir.resolve(), args.target
+        )
+
+        tex = TexInterface()
+        tex.build(settings)
+
     logger.info("Finished conversion")
 
 
+def plot(args):
+
+    launch_common(args)
+
+    config = read_yaml(args.config.resolve())
+
+    plotter = MatplotlibPlotter()
+    if ["plots"] in config:
+        for eachplot in config["plots"]:
+            plot = Plot(**eachplot)
+            plotter.plot(plot, args.output_dir.resolve())
+
+
 def main_cli():
     parser = argparse.ArgumentParser()
     parser.add_argument(
@@ -61,8 +86,23 @@ def main_cli():
         default="",
         help="Path to file to be converted to",
     )
+    convert_parser.add_argument(
+        "--build_dir",
+        default=Path(os.getcwd()) / "_build/tikz",
+        help="Path for build output",
+    )
     convert_parser.set_defaults(func=convert)
 
+    plot_parser = subparsers.add_parser("plot")
+    plot_parser.add_argument("--config", type=Path, help="Path to the plot config")
+    plot_parser.add_argument(
+        "--output_dir",
+        type=Path,
+        default=Path(os.getcwd()),
+        help="Path to the plot output directory",
+    )
+    plot_parser.set_defaults(func=plot)
+
     args = parser.parse_args()
     args.func(args)
 

icplot-0.0.11/src/icplot/tex_interface.py

@@ -0,0 +1,83 @@
+"""
+This module has functionality for publishing Tex documents
+"""
+
+import subprocess
+from typing import NamedTuple
+import shutil
+import os
+from pathlib import Path
+import logging
+
+from .image_utils import pdf_to_png
+
+logger = logging.getLogger(__name__)
+
+
+class TexBuildSettings(NamedTuple):
+    """
+    This holds settings for the Tex build
+    """
+
+    source: Path
+    build_dir: Path
+    output_dir: Path | None = None
+    build_engine: str = "pdflatex"
+    output_png: bool = True
+    clear_workdir: bool = True
+
+
+class TexInterface:
+    """
+    This is an interface to Tex for building Tex doucments.
+    """
+
+    def build_pdf(self, settings: TexBuildSettings, work_dir: Path):
+
+        cmd = f"{settings.build_engine} {settings.source}"
+
+        with open(work_dir / "stdout.txt", "w", encoding="utf-8") as f:
+            subprocess.run(
+                cmd, shell=True, check=True, cwd=work_dir, stdout=f, stderr=f
+            )
+
+    def build_single(self, settings: TexBuildSettings):
+        logger.info("Building source: %s", settings.source)
+
+        # Make a working dir
+        work_dir = settings.build_dir / settings.source.stem
+        os.makedirs(work_dir, exist_ok=True)
+
+        self.build_pdf(settings, work_dir)
+
+        tex_path = work_dir / settings.source.name
+        pdf_path = tex_path.parent / f"{tex_path.stem}.pdf"
+        if settings.output_png:
+            pdf_to_png(pdf_path)
+
+        # If output dir is different to build dir copy final content there
+        if settings.output_dir and settings.output_dir != work_dir:
+            os.makedirs(settings.output_dir, exist_ok=True)
+            shutil.copy(pdf_path, settings.output_dir)
+
+            if settings.output_png:
+                png_path = pdf_path.parent / f"{tex_path.stem}.png"
+                shutil.copy(png_path, settings.output_dir)
+
+            if settings.clear_workdir:
+                shutil.rmtree(work_dir)
+
+    def build(self, settings: TexBuildSettings):
+        if settings.source.is_dir():
+            for tex_file in settings.source.glob("*.tex"):
+                single_build = TexBuildSettings(
+                    tex_file,
+                    settings.build_dir,
+                    settings.output_dir,
+                    settings.build_engine,
+                )
+                self.build_single(single_build)
+        else:
+            self.build_single(settings)
+
+        logger.info("Finished building sources")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icplot
-Version: 0.0.10
+Version: 0.0.11
 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.1.0
+Requires-Dist: iccore==0.1.1
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
@@ -62,6 +62,12 @@ To covert between image formats you can do:
 icplot convert --source my_image.svg --target my_image.png
 ```
 
+To render a Tex tikz image as pdf and png you can do:
+
+``` shell
+icplot convert --source my_tikz.tex
+```
+
 # Copyright #
 
 Copyright 2024 Irish Centre for High End Computing

{icplot-0.0.10 → icplot-0.0.11}/src/icplot.egg-info/requires.txt

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

icplot-0.0.11/test/test_line_plots.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+
+from icplot.graph import Plot, LinePlotSeries
+from icplot.graph.matplotlib import MatplotlibPlotter
+
+
+def test_line_plot():
+
+    data = [([0, 5, 10], [1, 2, 3]), ([0, 5, 10], [3, 6, 9]), ([0, 5, 10], [4, 8, 12])]
+
+    series = []
+    for idx, [x, y] in enumerate(data):
+        series_config = {"label" : f"Series {idx}", "x" : x, "y" : y}
+        series.append(LinePlotSeries(**series_config))
+        
+    plot_config = {"title": "test",
+                   "legend_label" : "test_legend",
+                   "series" : series,
+                   "x_axis" : {"label" : "test_x",
+                               "ticks" : {"lower" : 0,
+                                          "upper" : 10,
+                                          "step" : 5}}}
+
+    plot = Plot(**plot_config)
+
+    output_path = Path() / "output.svg"
+
+    plotter = MatplotlibPlotter()
+    plotter.plot(plot, output_path)
+
+    assert output_path.exists()
+    output_path.unlink()

icplot-0.0.11/test/test_tex_interface.py

@@ -0,0 +1,24 @@
+import shutil
+from pathlib import Path
+
+from iccore.test_utils import get_test_data_dir, get_test_output_dir
+
+from icplot.tex_interface import TexBuildSettings, TexInterface
+
+
+def test_tex_interface():
+
+    data_dir = get_test_data_dir()
+    build_dir = get_test_output_dir()
+    source = data_dir / "test.tex"
+    
+    settings = TexBuildSettings(source, build_dir, build_dir)
+    
+    tex = TexInterface()
+
+    tex.build(settings)
+
+    assert Path(build_dir / "test.pdf").exists()
+    assert Path(build_dir / "test.png").exists()
+    
+    shutil.rmtree(build_dir)

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

@@ -1,44 +0,0 @@
-"""
-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/plot.py

@@ -1,92 +0,0 @@
-"""
-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/series.py

@@ -1,111 +0,0 @@
-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.10/src/icplot/tex_interface.py

@@ -1,92 +0,0 @@
-import argparse
-import subprocess
-import shutil
-import os
-from pathlib import Path
-import logging
-
-from .image_utils import pdf_to_png
-
-logger = logging.getLogger(__name__)
-
-
-class TexInterface:
-    def __init__(self, build_dir: Path | None, output_dir: Path | None):
-
-        if build_dir:
-            self.build_dir: Path = build_dir.resolve()
-        else:
-            self.build_dir = Path()
-        if not output_dir:
-            self.output_dir: Path = self.build_dir
-        else:
-            self.output_dir = output_dir.resolve()
-        self.build_engine = "pdflatex"
-
-    def build_pdf(self, source_path: Path, build_dir: Path):
-        cmd = f"{self.build_engine} {source_path}"
-        subprocess.run(cmd, shell=True, check=True, cwd=build_dir)
-
-    def build_single(self, source_path: Path):
-        logging.info("Building source: %s", source_path)
-
-        # Make a working dir
-        work_dir = self.build_dir / source_path.stem
-        os.makedirs(work_dir, exist_ok=True)
-
-        tex_path = work_dir / source_path.name
-        shutil.copy(source_path, tex_path)
-
-        self.build_pdf(tex_path, work_dir)
-
-        pdf_path = tex_path.parent / f"{tex_path.stem}.pdf"
-        pdf_to_png(pdf_path)
-
-        # If output dir is different to build dir copy final content there
-        if self.output_dir != self.build_dir:
-            png_path = pdf_path.parent / f"{tex_path.stem}.png"
-            shutil.copy(pdf_path, self.output_dir)
-            shutil.copy(png_path, self.output_dir)
-
-    def build(self, search_path: Path):
-
-        if not search_path.is_absolute():
-            search_path = Path(os.getcwd()) / search_path
-
-        os.makedirs(self.output_dir, exist_ok=True)
-
-        if search_path.is_dir():
-            for tex_file in search_path.glob("*.tex"):
-                self.build_single(tex_file)
-        else:
-            self.build_single(search_path)
-
-        logger.info("Finished building sources")
-
-
-if __name__ == "__main__":
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--source",
-        type=Path,
-        help="Path to the tikz source",
-    )
-    parser.add_argument(
-        "--build_dir",
-        type=Path,
-        default=Path(os.getcwd()) / "_build/tikz",
-        help="Path for build output",
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=Path,
-        default="",
-        help="Optional dir to collect build output",
-    )
-
-    logging.basicConfig(encoding="utf-8", level=logging.INFO)
-    args = parser.parse_args()
-
-    tex = TexInterface(args.build_dir, args.output_dir)
-    tex.build(args.source)

icplot-0.0.10/test/test_line_plots.py

@@ -1,29 +0,0 @@
-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.10/test/test_tex_interface.py

@@ -1,18 +0,0 @@
-import os
-import shutil
-from pathlib import Path
-from icplot.tex_interface import TexInterface
-
-
-def test_tex_interface():
-
-    build_dir = Path(os.getcwd()) / "tmp_build"
-    tex = TexInterface(build_dir, build_dir)
-
-    data_dir = Path(__file__).parent / "data"
-    tex_file = data_dir / "test.tex"
-
-    tex = TexInterface(build_dir, build_dir)
-    tex.build(tex_file)
-
-    shutil.rmtree(build_dir)