icplot 0.1.5__tar.gz → 0.1.7__tar.gz

{icplot-0.1.5/src/icplot.egg-info → icplot-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icplot
-Version: 0.1.5
+Version: 0.1.7
 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,10 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: wand
 Requires-Dist: matplotlib
-Requires-Dist: iccore==0.1.9
+Requires-Dist: vtk
+Requires-Dist: moviepy
+Requires-Dist: scipy
+Requires-Dist: iccore==0.1.13
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

icplot-0.1.7/pyproject.toml

@@ -0,0 +1,155 @@
+[project]
+name = "icplot"
+version = "0.1.7"
+authors = [
+  { name="James Grogan, Irish Centre for High End Computing", email="james.grogan@ichec.ie" },
+]
+description = "Utilities for generating plots and graphics for technical reports."
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Operating System :: OS Independent",
+    "Topic :: System :: Distributed Computing"
+]
+keywords = ["Publishing", "Technical Reports", "Graphics"]
+
+dependencies = ["wand",
+	       "matplotlib",
+               "vtk",
+               "moviepy",
+               "scipy",
+	       "iccore==0.1.13"]
+
+[project.urls]
+Repository = "https://git.ichec.ie/performance/toolshed/icplot"
+Homepage = "https://git.ichec.ie/performance/toolshed/icplot"
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pytest-cov",
+    "pytest-sugar",
+    "black",
+    "mypy",
+    "flake8",
+    "pylint"
+]
+
+cairo = [
+   "pycairo",
+   "CairoSVG"
+]
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project.scripts]
+icplot = "icplot.main_cli:main_cli"
+
+[tool.setuptools.package-data]
+"icplot" = ["py.typed", "controlDict"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.mypy]
+ignore_missing_imports = true
+
+[tool.pylint.main]
+
+source-roots = ["src"]
+fail-under = 9.2
+
+[tool.pylint.basic]
+
+class-const-naming-style = "UPPER_CASE"
+class-naming-style = "PascalCase"
+const-naming-style = "UPPER_CASE"
+docstring-min-length = -1
+
+function-naming-style = "snake_case"
+method-naming-style = "snake_case"
+module-naming-style = "snake_case"
+variable-naming-style = "snake_case"
+
+no-docstring-rgx = "^_"
+
+[tool.pylint.design]
+# Maximum number of arguments for function / method.
+max-args = 6
+# Maximum number of attributes for a class (see R0902).
+max-attributes = 7
+# Minimum number of public methods for a class (see R0903).
+min-public-methods = 1
+
+[tool.pylint.logging]
+# The type of string formatting that logging methods do. `old` means using %
+# formatting, `new` is for `{}` formatting.
+logging-format-style = "old"
+
+# Disable the message, report, category or checker with the given id(s). You can
+# either give multiple identifiers separated by comma (,) or put this option
+# multiple times (only on the command line, not in the configuration file where
+# it should appear only once). You can also use "--disable=all" to disable
+# everything first and then re-enable specific checks. For example, if you want
+# to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use "--disable=all --enable=classes
+# --disable=W".
+disable = ["raw-checker-failed", "missing-module-docstring", "missing-function-docstring", "bad-inline-option", "locally-disabled", "file-ignored", "suppressed-message", "useless-suppression", "deprecated-pragma", "use-symbolic-message-instead", "use-implicit-booleaness-not-comparison-to-string", "use-implicit-booleaness-not-comparison-to-zero"]
+
+[tool.pytest.ini_options]
+testpaths = ["test",]
+log_cli = 1
+log_cli_level = "debug"
+addopts = "--cov=icplot --cov-report term --cov-fail-under=59 --cov-report xml:coverage.xml --cov-report html"
+
+[tool.tox]
+requires = ["tox"]
+env_list = ["format_check", "lint", "style", "type", "3.10", "3.13", "docs"]
+skip_missing_interpreters = true
+
+[tool.tox.env_run_base]
+description = "Run Unit and Integration Tests"
+deps = [".[test, cairo]"]
+commands = [["pytest", "test"]]
+
+[tool.tox.env.format_apply]
+description = "Run Format Apply"
+skip_install = true
+deps = ["black"]
+commands = [["black", "src"], ["black", "test"]]
+
+[tool.tox.env.format_check]
+description = "Run Format Check"
+skip_install = true
+deps = ["black"]
+commands = [
+         ["black", "--check", "--diff", "src"],
+         ["black", "--check", "--diff", "test"]]
+
+[tool.tox.env.lint]
+description = "Run Linter"
+deps = ["pylint"]
+commands = [["pylint", "src"]]
+
+[tool.tox.env.style]
+description = "Run Style Check"
+skip_install = true
+deps = ["flake8"]
+commands = [["flake8", "src"]]
+
+[tool.tox.env.type]
+description = "Run Type Checks"
+deps = ["mypy", ".[types]"]
+commands = [["mypy", "src"]]
+
+[tool.tox.env.docs]
+description = "Generate Documentation"
+changedir = "docs"
+deps = ["sphinx"]
+commands = [["sphinx-build","-W", "-b","html","-d","{envtmpdir}/doctrees","."," {envtmpdir}/html"]]

{icplot-0.1.5 → icplot-0.1.7}/src/icplot/cairo_interface.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 import cairo
 
-from .geometry import Scene, Rectangle
+from .scene import Scene, Rectangle
 
 
 def draw_rect(cr, rect: Rectangle):

{icplot-0.1.5 → icplot-0.1.7}/src/icplot/gantt/gantt.py

@@ -1,3 +1,7 @@
+"""
+This module represents a gantt chard
+"""
+
 from datetime import datetime
 
 from pydantic import BaseModel
@@ -8,6 +12,9 @@ from icplot.color import Color
 
 
 class GanttChart(BaseModel, frozen=True):
+    """
+    A gantt chart
+    """
 
     milestones: list[Milestone] = []
     title: str = ""

{icplot-0.1.5 → icplot-0.1.7}/src/icplot/gantt/gantt_renderer.py

@@ -1,5 +1,5 @@
 from iccore.project import Milestone
-from icplot.geometry import Scene, SceneItem, Rectangle
+from icplot.scene import Scene, SceneItem, Rectangle
 
 from .gantt import GanttChart
 
@@ -25,10 +25,11 @@ def _render_milestone(
     return rect
 
 
-def _render_milestones(gantt: GanttChart):
+def _render_milestones(gantt: GanttChart) -> list[SceneItem]:
 
+    scene_items: list = []
     if not gantt.milestones:
-        return
+        return scene_items
 
     milestones = gantt.milestones
     # milestones.sort(key=lambda x: x.start_date, reverse=True)
@@ -44,7 +45,7 @@ def _render_milestones(gantt: GanttChart):
     chart_range = (start_date, end_date)
     yloc = 0.0
     bar_height = gantt.bar_max_height * gantt.height
-    scene_items = []
+
     for milestone in milestones:
         item = _render_milestone(gantt, milestone, chart_range, yloc)
         scene_items.append(item)

icplot-0.1.7/src/icplot/geometry.py

@@ -0,0 +1,209 @@
+"""
+Module for primitive geometries. This is used to keep dependencies simple,
+consider a real geometry library like cgal for more complex or performance
+dependent work.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+
+@dataclass(frozen=True)
+class Vector:
+    """
+    A 3d spatial vector
+    """
+
+    x: float
+    y: float = 0.0
+    z: float = 0.0
+
+    def scale(self, factor: float) -> Vector:
+        return Vector(self.x * factor, self.y * factor, self.z * factor)
+
+    def as_array(self) -> np.ndarray:
+        return np.array([self.x, self.y, self.z])
+
+
+@dataclass(frozen=True)
+class Point:
+    """
+    A location in 3d space
+    """
+
+    x: float
+    y: float = 0.0
+    z: float = 0.0
+
+    def as_array(self) -> np.ndarray:
+        return np.array([self.x, self.y, self.z])
+
+    def translate(self, v: Vector) -> Point:
+        return Point(self.x + v.x, self.y + v.y, self.z + v.z)
+
+    @staticmethod
+    def from_array(arr: np.ndarray) -> Point:
+        return Point(arr[0], arr[1], arr[2])
+
+
+@dataclass(frozen=True)
+class Shape:
+    """
+    A shape in 3d space, defaults to having a normal to Z
+    """
+
+    loc: Point = Point(0.0, 0.0, 0.0)
+    normal: Vector = Vector(0.0, 0.0, 1.0)
+
+
+def get_rotation_matrix(vec0, vec1):
+    """get rotation matrix between two vectors using scipy"""
+    vec0 = np.reshape(vec0, (1, -1))
+    vec1 = np.reshape(vec1, (1, -1))
+    r = Rotation.align_vectors(vec0, vec1)
+    return r[0].as_matrix()
+
+
+def get_normal(p0, p1, p2):
+    direction = np.cross(p1 - p0, p2 - p0)
+    return direction / np.linalg.norm(direction)
+
+
+_GLOBAL_Z = np.array([0.0, 0.0, 1.0])
+
+
+@dataclass(frozen=True)
+class Quad(Shape):
+    """
+    A regular quadrilateral in 3d space, defaults to be normal to Z
+    """
+
+    width: float = 1.0
+    height: float = 1.0
+
+    @property
+    def points(self) -> list[Point]:
+
+        points = [
+            self.loc.translate(Vector(-self.width / 2.0, -self.height / 2.0)),
+            self.loc.translate(Vector(self.width / 2.0, -self.height / 2.0)),
+            self.loc.translate(Vector(self.width / 2.0, self.height / 2.0)),
+            self.loc.translate(Vector(-self.width / 2.0, self.height / 2.0)),
+        ]
+
+        rot = get_rotation_matrix(_GLOBAL_Z, self.normal.as_array())
+        rotated_points = [
+            Point.from_array(
+                rot.dot(p.as_array() - self.loc.as_array()) + self.loc.as_array()
+            )
+            for p in points
+        ]
+
+        plane_normal = get_normal(
+            rotated_points[0].as_array(),
+            rotated_points[1].as_array(),
+            rotated_points[3].as_array(),
+        )
+
+        if np.dot(plane_normal, self.normal.as_array()) < 0:
+            rotated_points.reverse()
+        return rotated_points
+
+    def translate(self, v: Vector) -> Quad:
+        return Quad(self.loc.translate(v), self.normal, self.width, self.height)
+
+
+@dataclass(frozen=True)
+class Cuboid(Shape):
+    """
+    A regular cuboid
+    """
+
+    width: float = 1.0
+    height: float = 1.0
+    depth: float = 1.0
+    top_width_scale: float = 1.0
+
+    def translate(self, v: Vector) -> Cuboid:
+        return Cuboid(
+            self.loc.translate(v), self.normal, self.width, self.height, self.depth
+        )
+
+    @property
+    def points(self) -> list[Point]:
+
+        base = Quad(
+            self.loc.translate(Vector(0.0, 0.0, -self.depth / 2.0)),
+            self.normal,
+            self.width,
+            self.height,
+        )
+
+        top = Quad(
+            self.loc.translate(Vector(0.0, 0.0, -self.depth / 2.0)),
+            self.normal,
+            self.width * self.top_width_scale,
+            self.height,
+        )
+        top = top.translate(self.normal.scale(self.depth))
+        return base.points + top.points
+
+
+@dataclass(frozen=True)
+class Cylinder(Shape):
+    """
+    A cylinder
+    """
+
+    diameter: float = 1.0
+    length: float = 1.0
+
+    @property
+    def start(self) -> Point:
+        return self.loc
+
+    @property
+    def end(self) -> Point:
+        return self.loc.translate(self.normal.scale(self.length))
+
+
+@dataclass(frozen=True)
+class Revolution(Shape):
+    """
+    A revolved profile sitting on the plane given by the loc
+    and normal and revolved about the normal.
+    """
+
+    diameter: float = 1.0
+    length: float = 1.0
+    profile: str = "arc"
+
+
+@dataclass(frozen=True)
+class CuboidGrid:
+    """
+    A irregular grid composed of cuboids. Can be useful for
+    generating topological meshes like OpenFoam's blockMesh.
+    """
+
+    x_locs: list[float]
+    y_locs: list[float]
+    z_locs: list[float]
+
+    @property
+    def cuboids(self) -> list[Cuboid]:
+        ret = []
+
+        for kdx, z in enumerate(self.z_locs[:-1]):
+            for jdx, y in enumerate(self.y_locs[:-1]):
+                for idx, x in enumerate(self.x_locs[:-1]):
+                    width = self.x_locs[idx + 1] - x
+                    height = self.y_locs[jdx + 1] - y
+                    depth = self.z_locs[kdx + 1] - z
+                    ret.append(
+                        Cuboid(Point(x, y, z), width=width, height=height, depth=depth)
+                    )
+        return ret

{icplot-0.1.5 → icplot-0.1.7}/src/icplot/graph/axis.py

@@ -28,7 +28,7 @@ class PlotAxis(BaseModel, frozen=True):
     """
 
     label: str = ""
-    ticks: Range | None = None
+    ticks: Range | list[int] | None = None
     scale: str = "linear"
     text_fontsize: int = 10
     tick_fontsize: int = 10
@@ -38,5 +38,7 @@ class PlotAxis(BaseModel, frozen=True):
     @property
     def resolved_ticks(self) -> list:
         if self.ticks:
-            return self.ticks.eval()
+            if isinstance(self.ticks, Range):
+                return self.ticks.eval()
+            return self.ticks
         return []

{icplot-0.1.5 → icplot-0.1.7}/src/icplot/graph/matplotlib.py

@@ -31,10 +31,7 @@ def str_exact_values_formatter(x, pos):
     then when using plain formatter values less than 1 come out as 0. A way around
     this is this custom formatter.
     """
-    if x.is_integer():
-        return str(int(x))
-    else:
-        return str(x)
+    return str(int(x)) if x.is_integer else str(x)
 
 
 def _set_legend_decorations(axs, plot):
@@ -80,9 +77,9 @@ def _set_y_axes_decorations(y_axes: list[PlotAxis], axs):
         if y_axis.max_ticks:
             axs[idx].yaxis.set_major_locator(plt.MaxNLocator(y_axis.max_ticks))
         for key, item in y_axis.limits.items():
-            if key == "bottom" or key == "ymin":
+            if key in ("bottom", "ymin"):
                 axs[idx].set_ylim(ymin=item)
-            elif key == "top" or key == "ymax":
+            elif key in ("top", "ymax"):
                 axs[idx].set_ylim(ymax=item)
 
 

icplot-0.1.7/src/icplot/graph/mpl.py

@@ -0,0 +1,216 @@
+"""
+Module to support plotting with matplotlib
+"""
+
+import os
+from pathlib import Path
+import shutil
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from iccore.data.quantity import Quantity
+from iccore.data.units import DateRange, to_date_str
+from iccore.data import Series, Array
+
+from .plot_group import PlotGroup
+from .video import images_to_video
+
+
+def get_axis_label_from_quantity(quantity: Quantity) -> str:
+
+    if quantity.name == "time":
+        return f"{quantity.long_name} (UTC)"
+
+    if quantity.unit.get_symbol():
+        return f"{quantity.long_name} ({quantity.unit.get_symbol()})"
+
+    return quantity.long_name
+
+
+def get_axis_label(array: Array) -> str:
+    return get_axis_label_from_quantity(array.quantity)
+
+
+def get_grid(series: Series):
+
+    if not series.x or not series.y:
+        raise RuntimeError("Series missing expected data")
+
+    return np.meshgrid(series.x.data, series.y.data)
+
+
+def save_plot(fig, path: Path, filename: str, file_prefix: str = ""):
+    plt.tight_layout()
+    prefix = f"{file_prefix}_" if file_prefix else ""
+    os.makedirs(path, exist_ok=True)
+    plt.savefig(path / f"{prefix}{filename}")
+    plt.clf()
+    plt.close(fig)
+
+
+def get_date_suffix(dates: DateRange | None) -> str:
+    if not dates:
+        return ""
+    if not dates.start or not dates.end:
+        return ""
+
+    return f"_FROM_{to_date_str(dates.start)}_TO_{to_date_str(dates.end)}"
+
+
+def plot_2d(
+    path: Path, config: PlotGroup, series: Series, quantity: str, file_prefix: str = ""
+):
+    """
+    Generate a contour plot for the provided quantity
+    """
+
+    if not series.x:
+        raise RuntimeError("Expected series with an x quantity")
+
+    if not series.y:
+        raise RuntimeError("Expected series with a y quantity.")
+
+    x, y = get_grid(series)
+
+    array = series.get_array(quantity)
+
+    fig, ax = plt.subplots()
+
+    ax.set_ylabel(get_axis_label(series.y))
+    ax.set_xlabel(get_axis_label(series.x))
+
+    if config.date_range:
+        start, end = config.date_range.as_tuple()
+        if start and end:
+            ax.set_xlim((start, end))  # type: ignore
+    fig.autofmt_xdate()
+
+    if config.contour.show_grid:
+        ax.grid(c="k", ls="-", alpha=0.3)
+
+    if False and array.quantity.has_limits:
+        cs = ax.contourf(
+            x,
+            y,
+            np.clip(array.data.T, array.quantity.limits[0], array.quantity.limits[1]),
+            cmap=config.contour.colormap,
+        )
+    else:
+        cs = ax.contourf(x, y, array.data.T, cmap=config.contour.colormap)
+
+    cbar = fig.colorbar(cs)
+    cbar.ax.set_ylabel(get_axis_label(array))
+
+    save_plot(
+        fig,
+        path,
+        f"{quantity}{get_date_suffix(config.date_range)}.{config.contour.format}",
+        file_prefix,
+    )
+
+
+def plot_1d(
+    path: Path, config: PlotGroup, series: Series, quantity: str, file_prefix: str = ""
+):
+    """
+    Generate a line plot for the provided quantity
+    """
+
+    if not series.x:
+        raise RuntimeError("Attempted to plot series without x data")
+
+    array = series.get_array(quantity)
+
+    fig, ax = plt.subplots()
+    ax.set_xlabel(get_axis_label(series.x))
+    ax.set_ylabel(get_axis_label(array))
+
+    if config.date_range:
+        ax.set_xlim(config.date_range.as_tuple())  # type: ignore
+    fig.autofmt_xdate()
+
+    if array.quantity.has_limits:
+        ax.set_ylim(array.quantity.limits)  # type: ignore
+
+    x = array.data.index.to_numpy(dtype="datetime64[ns]")
+    y = array.data.values
+    ax.plot(x, y)
+
+    save_plot(
+        fig,
+        path,
+        f"{quantity}{get_date_suffix(config.date_range)}.{config.line.format}",
+        file_prefix,
+    )
+
+
+def plot_array(path: Path, series: Series, array: Array, file_prefix):
+    """
+    Plot an array for a single series x value. Useful for
+    time series video frames.
+    """
+
+    if not series.x or not series.y:
+        raise RuntimeError("Attempted to plot series with missing data")
+
+    for idx, (x, values) in enumerate(zip(series.x.data, array.data)):
+        fig, ax = plt.subplots()
+
+        ax.set_title(x)
+        ax.set_xlabel(get_axis_label(array))
+        ax.set_ylabel(get_axis_label(series.y))
+
+        if array.quantity.has_limits:
+            ax.set_xlim(array.quantity.limits)  # type: ignore
+
+        ax.plot(values, series.y.data)
+
+        prefix = f"{file_prefix}_" if file_prefix else ""
+        save_plot(fig, path / f"{prefix}{array.quantity.name}", f"{idx}.png")
+
+
+def make_video(
+    path: Path, config: PlotGroup, series: Series, quantity: str, file_prefix: str = ""
+):
+    plot_array(path, series, series.get_array(quantity), file_prefix)
+
+    prefix = f"{file_prefix}_" if file_prefix else ""
+
+    if not config.video:
+        return
+
+    images_to_video(
+        path / f"{prefix}{quantity}",
+        path,
+        f"{prefix}{quantity}{get_date_suffix(config.date_range)}",
+        fps=config.video.fps,
+        video_format=config.video.format,
+    )
+    shutil.rmtree(path / f"{prefix}{quantity}")
+
+
+def plot(
+    path: Path,
+    config: PlotGroup,
+    series: Series,
+    quantity: Quantity,
+    file_prefix: str = "",
+):
+    """
+    Handle plotting 1-d and 2-d time series and videos for the given quantity
+    """
+
+    if series.is_compound:
+        for c in series.components:
+            plot(path, config, c, quantity, c.name)
+        return
+
+    if series.y:
+        plot_2d(path, config, series, quantity.name, file_prefix)
+
+        if config.video and config.video.active:
+            make_video(path, config, series, quantity.name, file_prefix)
+        return
+
+    plot_1d(path, config, series, quantity.name, file_prefix)