matplotlib-sankey 0.2.1__py3-none-any.whl

matplotlib_sankey/__init__.py

@@ -0,0 +1,5 @@
+from ._plotting import sankey
+from ._version import __version__
+from ._utils import from_matrix
+
+__all__ = ["sankey", "__version__", "from_matrix"]

matplotlib_sankey/_patches.py

@@ -0,0 +1,143 @@
+from matplotlib.patches import PathPatch
+from matplotlib.path import Path
+
+from matplotlib_sankey._types import AcceptedColors
+
+
+def patch_line(
+    x_start: float,
+    x_end: float,
+    y1_start: float,
+    y1_end: float,
+    y2_start: float,
+    y2_end: float,
+    row_index: int,
+    spacing: float = 0.0,
+    alpha: float = 0.5,
+    color: AcceptedColors | None = None,
+) -> PathPatch:
+    """Generate line patch."""
+    path_patch_kwargs = {
+        "color": color,
+        "zorder": 0,
+        "alpha": alpha,
+        "lw": 0,
+    }
+
+    return PathPatch(
+        Path(
+            vertices=[
+                (x_start, y1_start + (spacing * row_index)),
+                (x_end, y1_end + (spacing * row_index)),
+                (x_end, y2_start + (spacing * row_index)),
+                (x_start, y2_end + (spacing * row_index)),
+            ],
+            codes=[Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO],
+            closed=True,
+        ),
+        **path_patch_kwargs,
+    )
+
+
+def patch_curve3(
+    x_start: float,
+    x_end: float,
+    y1_start: float,
+    y1_end: float,
+    y2_start: float,
+    y2_end: float,
+    row_index: int,
+    spacing: float = 0.0,
+    alpha: float = 0.5,
+    color: AcceptedColors | None = None,
+) -> PathPatch:
+    """Generate curve3 patch."""
+    path_patch_kwargs = {
+        "color": color,
+        "zorder": 0,
+        "alpha": alpha,
+        "lw": 0,
+    }
+
+    x_middle = ((x_end - x_start) / 2) + x_start
+
+    return PathPatch(
+        Path(
+            vertices=[
+                (x_start, y1_start + (spacing * row_index)),
+                (x_middle, y1_start + (spacing * row_index)),
+                (x_middle, (y1_start - y1_end) / 2 + y1_end + (spacing * row_index)),
+                (x_middle, y1_end + (spacing * row_index)),
+                (x_end, y1_end + (spacing * row_index)),
+                (x_end, y2_start + (spacing * row_index)),
+                (x_middle, y2_start + (spacing * row_index)),
+                (x_middle, (y2_start - y2_end) / 2 + y2_end + (spacing * row_index)),
+                (x_middle, y2_end + (spacing * row_index)),
+                (x_start, y2_end + (spacing * row_index)),
+            ],
+            codes=[
+                Path.MOVETO,
+                Path.CURVE3,
+                Path.CURVE3,
+                Path.CURVE3,
+                Path.CURVE3,
+                Path.LINETO,
+                Path.CURVE3,
+                Path.CURVE3,
+                Path.CURVE3,
+                Path.CURVE3,
+            ],
+            closed=True,
+        ),
+        **path_patch_kwargs,
+    )
+
+
+def patch_curve4(
+    x_start: float,
+    x_end: float,
+    y1_start: float,
+    y1_end: float,
+    y2_start: float,
+    y2_end: float,
+    row_index: int,
+    spacing: float = 0.0,
+    alpha: float = 0.5,
+    color: AcceptedColors | None = None,
+) -> PathPatch:
+    """Generate curve3 patch."""
+    path_patch_kwargs = {
+        "color": color,
+        "zorder": 0,
+        "alpha": alpha,
+        "lw": 0,
+    }
+
+    x_middle = ((x_end - x_start) / 2) + x_start
+
+    return PathPatch(
+        Path(
+            vertices=[
+                (x_start, y1_start + (spacing * row_index)),
+                (x_middle, y1_start + (spacing * row_index)),
+                (x_middle, y1_end + (spacing * row_index)),
+                (x_end, y1_end + (spacing * row_index)),
+                (x_end, y2_start + (spacing * row_index)),
+                (x_middle, y2_start + (spacing * row_index)),
+                (x_middle, y2_end + (spacing * row_index)),
+                (x_start, y2_end + (spacing * row_index)),
+            ],
+            codes=[
+                Path.MOVETO,
+                Path.CURVE4,
+                Path.CURVE4,
+                Path.CURVE4,
+                Path.LINETO,
+                Path.CURVE4,
+                Path.CURVE4,
+                Path.CURVE4,
+            ],
+            closed=True,
+        ),
+        **path_patch_kwargs,
+    )

matplotlib_sankey/_plotting.py

@@ -0,0 +1,269 @@
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+from matplotlib.patches import Rectangle, PathPatch, Patch
+from matplotlib.ticker import FixedLocator
+
+from ._types import AcceptedColors, CurveType
+from ._utils import _clean_axis, _generate_cmap
+from ._patches import patch_curve3, patch_curve4, patch_line
+
+
+def sankey(
+    data: list[list[tuple[int | str, int | str, float | int]]],
+    figsize: tuple[int, int] | None = None,
+    frameon: bool = False,
+    ax: Axes | None = None,
+    spacing: float = 0.00,
+    annotate_columns: bool = False,
+    rel_column_width: float = 0.15,
+    cmap: AcceptedColors = "tab10",
+    curve_type: CurveType = "curve4",
+    ribbon_alpha: float = 0.2,
+    ribbon_color: str = "black",
+    title: str | None = None,
+    show: bool = True,
+    show_legend: bool = False,
+    legend_labels: list[str] | None = None,
+    column_labels: list[str] | None = None,
+) -> Axes:
+    """Sankey plot.
+
+    Args:
+        data (list[list[tuple[int | str, int | str, float | int]]]): Input data.
+        figsize (tuple[int, int] | None): Size of figure. Defaults to `None`.
+        frameon (bool, optional): Draw frame. Defaults to `True`.
+        ax (matplotlib.Axes | None, optional): Provide matplotlib Axes instance for plotting. Defaults to `None`.
+        spacing (float, optional): Spacing between column and ribbon patches. Defaults to `0.0`.
+        annotate_columns (bool, optional): Annotate columns of plot. Defaults to `False`.
+        rel_column_width (float, optional): Relative width of columns compared to ribbons. Defaults to `0.15`. Value must be between 0 and 1.
+        cmap (Sequence[str] | Colormap | str | Sequence[tuple[float, float, float]], optional): Colors or colormap for columns.
+        curve_type (Literal["curve3", "curve4", "line"], optional): Curve type ofo ribbon. Defaults to `"curve4"`.
+        ribbon_alpha (float, optional): Alpha of ribbons. Defaults to `0.2`.
+        ribbon_color (str, optional): Color of ribbons. Defaults to `"black"`.
+        title (str | None, optional): Title of figure. Defaults to `None`.
+        show (bool, optional): Show figure. Defaults to `True`.
+        show_legend (bool, optional): Show legend. Defaults to `False`. If legend should be displayed, also provide `legend_labels`.
+        legend_labels (list[str] | None, optional): Labels to display in legend. Defaults to `None`.
+        column_labels (list[str] | None, optional): Labels for columns. Defaults to `None`.
+
+    Returns:
+        Matplotlib axes instance.
+
+    ReturnType:
+        matplitlib.Axes
+
+    """
+    assert rel_column_width > 0 and rel_column_width < 1, (
+        "Value for parameter 'rel_column_width' must be between 0 and 1."
+    )
+
+    if ax is None:
+        _, ax = plt.subplots(figsize=figsize, frameon=frameon)
+
+    ncols = len(data) + 1
+
+    ax = _clean_axis(ax, frameon=frameon)
+
+    ax.set_ylim(0.0, 1.0)
+    ax.set_xlim(-1 * (rel_column_width / 2), (ncols - 1) + (rel_column_width / 2))
+
+    if column_labels is not None:
+        ax.xaxis.set_major_locator(FixedLocator(list(range(ncols))))
+
+    # Prepare data
+    column_weights: list[dict[int | str, int | float]] = [{} for _ in range(ncols)]
+
+    cmap = _generate_cmap(cmap, 20)
+
+    for frame_index, frame in enumerate(data):
+        for source_index, target_index, weight in frame:
+            if column_weights[frame_index] is None:
+                column_weights[frame_index] = {
+                    source_index: weight,
+                }
+            else:
+                column_weights[frame_index][source_index] = column_weights[frame_index].get(source_index, 0) + weight
+
+            if frame_index == len(data) - 1:
+                # Add weights for last column
+                if column_weights[frame_index + 1] is None:
+                    column_weights[frame_index + 1] = {
+                        target_index: weight,
+                    }
+                else:
+                    column_weights[frame_index + 1][target_index] = (
+                        column_weights[frame_index + 1].get(target_index, 0) + weight
+                    )
+
+    # Plot rectangles
+    column_rects: list[dict[int | str, tuple[float, float, float, float]]] = [{} for _ in range(ncols)]
+    rect_num = 0
+
+    legend_handles: list[tuple[str, tuple[float, float, float, float]]] = []
+
+    for frame_index in range(ncols):
+        column_total_weight = sum(column_weights[frame_index].values())
+        column_prev_weight = 0.0
+
+        column_n_spacing = len(column_weights[frame_index].values()) - 1
+
+        spacing_scale_factor = 1 - (spacing * column_n_spacing)
+
+        for column_index, (column_key, weights) in enumerate(column_weights[frame_index].items()):
+            rect_x = frame_index - (rel_column_width / 2)
+            rect_y = column_prev_weight / column_total_weight + (column_index * spacing)
+            rect_height = (weights * spacing_scale_factor) / column_total_weight
+
+            column_prev_weight += weights * spacing_scale_factor
+
+            rect = Rectangle(
+                xy=(
+                    rect_x,
+                    rect_y,
+                ),
+                width=rel_column_width,
+                height=rect_height,
+                color=cmap(rect_num),
+                zorder=1,
+                lw=0,
+            )
+            ax.add_patch(rect)
+
+            # Save in lookup dict
+            if column_rects[frame_index] is None:
+                column_rects[frame_index] = {column_key: (rect_x, rect_y, rel_column_width, rect_height)}
+            else:
+                column_rects[frame_index][column_key] = (rect_x, rect_y, rel_column_width, rect_height)
+
+            if annotate_columns is True:
+                ax.text(
+                    x=rect_x + (rel_column_width / 2),
+                    y=rect_y + (rect_height / 2),
+                    s=str(column_key),
+                    ha="center",
+                    va="center",
+                )
+
+            legend_handles.append((str(column_key), cmap(rect_num)))
+
+            rect_num += 1
+
+    # Plot ribbons
+
+    for frame_index in range(ncols - 1):
+        target_ribbon_offset: dict[int | str, int | float] = {}
+
+        for column_key in column_weights[frame_index].keys():
+            # print(column_key)
+            # Source rect dimensions
+            rect_x, rect_y, _, rect_height = column_rects[frame_index][column_key]
+
+            # Get all connection targets
+            column_targets: dict[int | str, float | int] = {}
+            for source, target, connection_weights in data[frame_index]:
+                if source == column_key:
+                    column_targets[target] = connection_weights
+
+            ribbon_offset: float = 0.0
+
+            for target_index, ribbon_weight in column_targets.items():
+                # Start coords
+                y1_start = rect_y + +(rect_height * (ribbon_offset / sum(column_targets.values())))
+                y2_end = rect_y + (rect_height * ((ribbon_offset + ribbon_weight) / sum(column_targets.values())))
+
+                ribbon_offset += ribbon_weight
+
+                _, target_rect_y, _, target_rect_height = column_rects[frame_index + 1][target_index]
+
+                # End coords
+                y1_end = target_rect_y + (
+                    target_rect_height
+                    * (target_ribbon_offset.get(target_index, 0) / column_weights[frame_index + 1][target_index])
+                )
+                y2_start = target_rect_y + (
+                    target_rect_height
+                    * (
+                        (ribbon_weight + target_ribbon_offset.get(target_index, 0))
+                        / column_weights[frame_index + 1][target_index]
+                    )
+                )
+
+                target_ribbon_offset[target_index] = target_ribbon_offset.get(target_index, 0) + ribbon_weight
+
+                poly: PathPatch
+
+                if curve_type == "curve4":
+                    poly = patch_curve4(
+                        x_start=frame_index + (rel_column_width / 2),
+                        x_end=frame_index + 1 - (rel_column_width / 2),
+                        y1_start=y1_start,
+                        y1_end=y1_end,
+                        y2_start=y2_start,
+                        y2_end=y2_end,
+                        row_index=0,
+                        alpha=ribbon_alpha,
+                        color=ribbon_color,
+                        spacing=0,
+                    )
+                elif curve_type == "curve3":
+                    poly = patch_curve3(
+                        x_start=frame_index + (rel_column_width / 2),
+                        x_end=frame_index + 1 - (rel_column_width / 2),
+                        y1_start=y1_start,
+                        y1_end=y1_end,
+                        y2_start=y2_start,
+                        y2_end=y2_end,
+                        row_index=0,
+                        alpha=ribbon_alpha,
+                        color=ribbon_color,
+                        spacing=0,
+                    )
+                elif curve_type == "line":
+                    poly = patch_line(
+                        x_start=frame_index + (rel_column_width / 2),
+                        x_end=frame_index + 1 - (rel_column_width / 2),
+                        y1_start=y1_start,
+                        y1_end=y1_end,
+                        y2_start=y2_start,
+                        y2_end=y2_end,
+                        row_index=0,
+                        alpha=ribbon_alpha,
+                        color=ribbon_color,
+                        spacing=0,
+                    )
+                else:
+                    raise ValueError(f"curve_type '{curve_type}' not supported.")
+
+                ax.add_patch(poly)
+
+    if show_legend is True:
+        legend_patches = []
+        for handle_index, (label, color) in enumerate(legend_handles):
+            if legend_labels is None:
+                legend_patches.append(Patch(facecolor=color, label=label))
+            else:
+                legend_patches.append(Patch(facecolor=color, label=legend_labels[handle_index]))
+
+        ax.legend(
+            handles=legend_patches,
+            frameon=False,
+            bbox_to_anchor=(1, 1),
+            loc="upper left",
+        )
+
+    if title is not None:
+        ax.set_title(title)
+
+    if show is False:
+        plt.close()
+    # else:
+    #     plt.show()
+
+    if column_labels is not None:
+        assert len(column_labels) == ncols
+        ax.set_xticklabels(column_labels)
+    # else:
+    #     ax.set_xticklabels(None)
+    #     ax.set_xticks([])
+
+    return ax

matplotlib_sankey/_types.py

@@ -0,0 +1,8 @@
+from collections.abc import Sequence
+from typing import Literal, TypeAlias
+
+from matplotlib.colors import Colormap
+
+CurveType: TypeAlias = Literal["curve3", "curve4", "line"]
+
+AcceptedColors: TypeAlias = Sequence[str] | Colormap | str | Sequence[tuple[float, float, float]]

matplotlib_sankey/_utils.py

@@ -0,0 +1,97 @@
+from collections.abc import Sequence
+
+import numpy as np
+from matplotlib import colormaps
+from matplotlib.axes import Axes
+from matplotlib.colors import Colormap, ListedColormap
+
+from ._types import AcceptedColors
+
+
+def _clean_axis(
+    _ax: Axes,
+    frameon: bool = True,
+    reset_x_ticks: bool = True,
+    reset_y_ticks: bool = True,
+) -> Axes:
+    """Helper function to clean axes."""
+    if reset_x_ticks is True:
+        _ax.set_xticklabels([])
+        _ax.set_xticks([])
+
+    if reset_y_ticks is True:
+        _ax.set_yticklabels([])
+        _ax.set_yticks([])
+        # _ax.set_ylim(0, 1)
+
+    if frameon is False:
+        # Despine
+        _ax.spines["top"].set_visible(False)
+        _ax.spines["left"].set_visible(False)
+        _ax.spines["right"].set_visible(False)
+        _ax.spines["bottom"].set_visible(False)
+    return _ax
+
+
+def _generate_cmap(value: AcceptedColors, nrows: int) -> Colormap:
+    """Util function to generate colormap from list of string or name."""
+
+    def _convert_sequential_cmap_to_listed(c: Colormap, threshold: int = 256) -> Colormap:
+        if c.N >= threshold:
+            return ListedColormap([c(i) for i in np.linspace(start=0, stop=c.N, num=nrows).astype(int)])
+
+        return c
+
+    if isinstance(value, str):
+        # String argument must be the name of an colormap
+        assert value in list(colormaps.keys()), f"Value '{value}' is not the name of a valid colormap."
+
+        return _convert_sequential_cmap_to_listed(colormaps.get_cmap(value))
+
+    elif isinstance(value, Sequence):
+        return ListedColormap(value)
+
+    elif isinstance(value, Colormap):
+        return _convert_sequential_cmap_to_listed(value)
+
+    raise TypeError(f"Type '{type(value).__name__}' not allowed.")
+
+
+def from_matrix(
+    mtx: Sequence[Sequence[int | float]],
+    source_indicies: list[int | str] | None = None,
+    target_indicies: list[int | str] | None = None,
+) -> Sequence[tuple[int | str, int | str, float | int]]:
+    """Convert weight matrix to tuple of source, target and weight.
+
+    Args:
+        mtx (Sequence[Sequence[int | float]], optional): Weight matrix (source x target).
+        source_indicies (list[int | str] | None, optional): List of source indices. Defaults to `None`.
+        target_indicies (list[int | str] | None, optional): List of target indices. Defaults to `None`.
+
+    Returns:
+        List of tuples containing source, target and weight.
+
+    ReturnType:
+        list[tuple[int | str, int | str, float | int]]
+
+    """
+    # Check correct dimensions of index list
+    if source_indicies is not None:
+        assert len(source_indicies) == len(mtx)
+    if target_indicies is not None:
+        assert len(target_indicies) == len(mtx[0])
+
+    connections = []
+    for row in range(len(mtx)):
+        for col in range(len(mtx[row])):
+            if mtx[row][col] > 0:
+                source_index: int | str = row
+                target_index: int | str = col
+
+                if source_indicies is not None:
+                    source_index = source_indicies[row]
+                if target_indicies is not None:
+                    target_index = target_indicies[col]
+                connections.append((source_index, target_index, mtx[row][col]))
+    return connections

matplotlib_sankey/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.1"

matplotlib_sankey-0.2.1.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: matplotlib-sankey
+Version: 0.2.1
+Summary: Sankey plot for matplotlib
+Author: harryhaller001
+Maintainer-email: harryhaller001 <harryhaller001@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Matplotlib
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+License-File: LICENSE
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: ipykernel ; extra == "docs"
+Requires-Dist: ipython ; extra == "docs"
+Requires-Dist: ipywidgets ; extra == "docs"
+Requires-Dist: myst-parser ; extra == "docs"
+Requires-Dist: nbsphinx ; extra == "docs"
+Requires-Dist: networkx[default] ; extra == "docs"
+Requires-Dist: sphinx>=4 ; extra == "docs"
+Requires-Dist: sphinx-autoapi ; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints ; extra == "docs"
+Requires-Dist: sphinx-book-theme>=1 ; extra == "docs"
+Requires-Dist: coverage ; extra == "test"
+Requires-Dist: flit ; extra == "test"
+Requires-Dist: mypy ; extra == "test"
+Requires-Dist: pre-commit ; extra == "test"
+Requires-Dist: pytest ; extra == "test"
+Requires-Dist: ruff ; extra == "test"
+Requires-Dist: setuptools ; extra == "test"
+Requires-Dist: twine>=4.0.2 ; extra == "test"
+Project-URL: Documentation, https://github.com/harryhaller001/matplotlib-sankey
+Project-URL: Homepage, https://github.com/harryhaller001/matplotlib-sankey
+Project-URL: Source, https://github.com/harryhaller001/matplotlib-sankey
+Provides-Extra: docs
+Provides-Extra: test
+
+# matplotlib-sankey
+
+Sankey plot for matplotlib
+
+### Installation
+
+Install with pip:
+
+`pip install matplotlib-sankey`
+
+Install from source:
+
+```bash
+git clone https://github.com/harryhaller001/matplotlib-sankey
+cd matplotlib-sankey
+pip install .
+```
+
+
+### Example
+
+```python
+data = [
+    # (source index, target index, weight)
+    [(0, 2, 20), (0, 1, 10), (3, 4, 15), (3, 2, 10), (5, 1, 5), (5, 2, 50)],
+    [(2, 6, 40), (1, 6, 15), (2, 7, 40), (4, 6, 15)],
+    [(7, 8, 5), (7, 9, 5), (7, 10, 20), (7, 11, 10), (6, 11, 55), (6, 8, 15)],
+]
+
+fig, ax = plt.subplots(figsize=(10, 5))
+fig.tight_layout()
+sankey(
+    data=data,
+    cmap="tab20",
+    annotate_columns=True,
+    ax=ax,
+    spacing=0.03,
+)
+```
+
+![Sankey plot example](./docs/source/_static/images/example_sankey_plot.jpg)
+
+
+
+### Development
+
+```bash
+python3.10 -m virtualenv venv
+source venv/bin/activate
+
+# Install dev dependencies
+make install
+```
+

matplotlib_sankey-0.2.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+matplotlib_sankey/__init__.py,sha256=1_BkFKWc5IsotEarp0lzZpFXQBvew07qnplc0_QNUkA,148
+matplotlib_sankey/_patches.py,sha256=3xYWHhAgbBD6yYF_qfqHezchZVAbXFUL9zSGhi-l3_A,3941
+matplotlib_sankey/_plotting.py,sha256=w3EEKSj2QT0XjpUt4juDjVvnPXyTt8VcYpe9BJ35Jow,10580
+matplotlib_sankey/_types.py,sha256=4BhTH8vndjpF8QZjW7l43xLvOdMYlFTPLVcu3KX3a_Q,274
+matplotlib_sankey/_utils.py,sha256=3CwG1cjuqh24tSKTzpvYxM7pew_o9ix0zalVYX0mr-I,3246
+matplotlib_sankey/_version.py,sha256=HfjVOrpTnmZ-xVFCYSVmX50EXaBQeJteUHG-PD6iQs8,22
+matplotlib_sankey-0.2.1.dist-info/licenses/LICENSE,sha256=pKQY7EaklCnxWGJNlxr2OrDtJrb6MuqlcDj-x4jHKmU,1071
+matplotlib_sankey-0.2.1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+matplotlib_sankey-0.2.1.dist-info/METADATA,sha256=UTPYBlLKk2hJzRVE4up3ZkYZ1FU_PJL4z-pypEEwbjU,2797
+matplotlib_sankey-0.2.1.dist-info/RECORD,,

matplotlib_sankey-0.2.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any

matplotlib_sankey-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 harryhaller001
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.