dendrofan 0.1.1__py3-none-any.whl

dendrofan/__init__.py

@@ -0,0 +1,62 @@
+"""
+dendrofan: circular ("fan") dendrograms for Python.
+
+dendrofan draws dendrograms bent onto an annulus, in the visual style
+of ``ape::plot.phylo(type = "fan")`` in R (Paradis & Schliep, 2019),
+using only NumPy, SciPy, and Matplotlib -- no R dependency, no
+reimplementation of clustering. It exists because
+``scipy.cluster.hierarchy`` has no circular layout mode: the usual
+workaround is a one-off script that manually re-projects
+``dendrogram()``'s rectangular ``icoord``/``dcoord`` output into polar
+coordinates. dendrofan generalizes that idea into a small, tested
+library: a documented coordinate transform
+(:class:`dendrofan.geometry.PolarTransform`) plus a plotting API that
+handles the edge cases a one-off script usually skips (single-leaf and
+two-leaf trees, all-zero merge heights, mismatched labels, partial fans
+with an angular gap, inward vs. outward root, etc).
+
+Quick start
+-----------
+>>> import numpy as np
+>>> from dendrofan import circular_dendrogram
+>>> rng = np.random.default_rng(0)
+>>> data = rng.normal(size=(12, 5))
+>>> result = circular_dendrogram(data, labels=[f"s{i}" for i in range(12)])
+>>> result.fig.savefig("tree.png", dpi=200)
+
+See :func:`circular_dendrogram` for the full parameter reference, and
+the ``examples/`` directory in the source distribution for worked
+examples, including one that reproduces a colored-by-group station
+dendrogram end to end.
+"""
+from ._version import __version__
+from .annotations import add_scale_ring, highlight_sector
+from .clustering import DendrogramLayout, build_layout
+from .exceptions import (
+    DegenerateTreeError,
+    DendrofanError,
+    InvalidLinkageError,
+    LabelMismatchError,
+)
+from .geometry import PolarTransform, arc_points, radial_label_alignment
+from .plotting import CircularDendrogramResult, circular_dendrogram
+from .styling import legend_handles, resolve_leaf_colors
+
+__all__ = [
+    "__version__",
+    "circular_dendrogram",
+    "CircularDendrogramResult",
+    "build_layout",
+    "DendrogramLayout",
+    "PolarTransform",
+    "arc_points",
+    "radial_label_alignment",
+    "add_scale_ring",
+    "highlight_sector",
+    "resolve_leaf_colors",
+    "legend_handles",
+    "DendrofanError",
+    "InvalidLinkageError",
+    "LabelMismatchError",
+    "DegenerateTreeError",
+]

dendrofan/_version.py

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

dendrofan/annotations.py

@@ -0,0 +1,109 @@
+"""Optional decorations for a circular dendrogram: scale rings and sector highlights.
+
+These operate on the ``ax``/``transform`` pair returned by
+:func:`dendrofan.plotting.circular_dendrogram`, so they can be added or
+omitted independently of the tree itself.
+"""
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+import numpy as np
+from matplotlib.axes import Axes
+
+from .geometry import PolarTransform
+
+
+def add_scale_ring(
+    ax: Axes,
+    transform: PolarTransform,
+    heights: Sequence[float],
+    *,
+    color: str = "gray",
+    linewidth: float = 0.6,
+    linestyle: str = "--",
+    label_heights: bool = True,
+    label_fontsize: float = 8,
+    label_angle: float = 90.0,
+) -> None:
+    """Draw concentric guide circles at the given linkage heights.
+
+    The circular analogue of the distance axis ``ape::axisPhylo()``
+    draws on a rectangular/fan tree: a light dashed ring at each height
+    in ``heights``, optionally labeled with the height value, so
+    readers can gauge merge distances even though a circular layout
+    has no literal axis line to read off.
+
+    Parameters
+    ----------
+    heights : sequence of float
+        Linkage heights (in the original units of the tree, i.e. of
+        ``dcoord`` / the linkage matrix) at which to draw a ring.
+        Heights outside ``[0, transform.y_max]`` are skipped.
+    label_angle : float, default 90
+        Angle, in degrees, at which each ring's height label is placed
+        (90 = top of the circle, matching ``start_angle``'s default).
+    """
+    theta = np.radians(label_angle)
+    for h in heights:
+        if h < 0 or h > transform.y_max:
+            continue
+        r = float(transform.radius(h))
+        circle = np.linspace(0, 2 * np.pi, 200)
+        ax.plot(
+            r * np.cos(circle),
+            r * np.sin(circle),
+            color=color,
+            linewidth=linewidth,
+            linestyle=linestyle,
+            zorder=0,
+        )
+        if label_heights:
+            ax.text(
+                r * np.cos(theta),
+                r * np.sin(theta),
+                f"{h:g}",
+                fontsize=label_fontsize,
+                color=color,
+                ha="center",
+                va="bottom",
+            )
+
+
+def highlight_sector(
+    ax: Axes,
+    transform: PolarTransform,
+    theta_start: float,
+    theta_end: float,
+    *,
+    r_inner: Optional[float] = None,
+    r_outer: Optional[float] = None,
+    color: str = "gray",
+    alpha: float = 0.15,
+    n_points: int = 100,
+    zorder: float = -1,
+) -> None:
+    """Shade a wedge of the plot behind a clade, the way ``ape``'s clade
+    highlighting (e.g. via ``ape::ring`` or manually drawn background
+    wedges) marks a group of related leaves.
+
+    Parameters
+    ----------
+    theta_start, theta_end : float
+        Angular bounds of the wedge, in radians (e.g. from
+        ``CircularDendrogramResult.leaf_theta_by_index``).
+    r_inner, r_outer : float, optional
+        Radial bounds of the wedge. Default to
+        ``transform.inner_radius`` and ``transform.outer_radius``
+        respectively, i.e. the whole tree depth.
+    """
+    r_inner = transform.inner_radius if r_inner is None else r_inner
+    r_outer = transform.outer_radius if r_outer is None else r_outer
+
+    thetas = np.linspace(theta_start, theta_end, n_points)
+    outer_x, outer_y = r_outer * np.cos(thetas), r_outer * np.sin(thetas)
+    inner_x, inner_y = r_inner * np.cos(thetas[::-1]), r_inner * np.sin(thetas[::-1])
+
+    xs = np.concatenate([outer_x, inner_x])
+    ys = np.concatenate([outer_y, inner_y])
+    ax.fill(xs, ys, color=color, alpha=alpha, linewidth=0, zorder=zorder)

dendrofan/clustering.py

@@ -0,0 +1,197 @@
+"""
+Turn raw data, a condensed distance vector, or a precomputed linkage
+matrix into the rectangular-dendrogram layout that :mod:`dendrofan.geometry`
+bends into a circle.
+
+This module is a thin, validating wrapper around
+``scipy.cluster.hierarchy`` -- dendrofan does not reimplement clustering,
+it only makes the SciPy output safe and convenient to consume for
+circular rendering.
+"""
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional, Sequence, Union
+
+import numpy as np
+from scipy.cluster.hierarchy import dendrogram as _scipy_dendrogram
+from scipy.cluster.hierarchy import is_valid_linkage, linkage as _scipy_linkage
+from scipy.spatial.distance import is_valid_y, pdist
+
+from .exceptions import DegenerateTreeError, InvalidLinkageError, LabelMismatchError
+
+
+@dataclasses.dataclass
+class DendrogramLayout:
+    """Rectangular-coordinate layout of a dendrogram, ready to be bent into a circle.
+
+    This mirrors (a validated, typed subset of) the dict returned by
+    ``scipy.cluster.hierarchy.dendrogram``.
+
+    Attributes
+    ----------
+    Z : ndarray
+        The linkage matrix underlying the tree.
+    icoord, dcoord : ndarray
+        Per-merge x (leaf-axis) and y (height-axis) coordinates, shape
+        ``(n_merges, 4)``, exactly as returned by SciPy: for merge *i*,
+        ``(icoord[i, 0], dcoord[i, 0])`` and ``(icoord[i, 3], dcoord[i, 3])``
+        are the two outer (leaf-ward) corners of the merge's "U" shape,
+        and ``dcoord[i, 1] == dcoord[i, 2]`` is the merge height.
+    leaves : list of int
+        Original observation indices, in left-to-right leaf order.
+    leaf_labels : list of str
+        Display labels, in the same left-to-right order as ``leaves``.
+    color_list : list of str
+        Per-merge color, as assigned by SciPy's ``color_threshold`` /
+        ``link_color_func`` machinery (one entry per row of ``icoord``).
+    n_leaves : int
+        Number of leaves in the tree.
+    """
+
+    Z: np.ndarray
+    icoord: np.ndarray
+    dcoord: np.ndarray
+    leaves: List[int]
+    leaf_labels: List[str]
+    color_list: List[str]
+
+    @property
+    def n_leaves(self) -> int:
+        return len(self.leaves)
+
+    @property
+    def x_min(self) -> float:
+        return float(self.icoord.min())
+
+    @property
+    def x_max(self) -> float:
+        return float(self.icoord.max())
+
+    @property
+    def y_max(self) -> float:
+        return float(self.dcoord.max())
+
+
+ArrayLike = Union[np.ndarray, Sequence[Sequence[float]]]
+
+
+def _validate_labels(labels: Optional[Sequence[str]], n_leaves: int) -> List[str]:
+    if labels is None:
+        return [str(i) for i in range(n_leaves)]
+    labels = list(labels)
+    if len(labels) != n_leaves:
+        raise LabelMismatchError(
+            f"got {len(labels)} labels for {n_leaves} leaves; "
+            "labels must have exactly one entry per observation"
+        )
+    return labels
+
+
+def build_layout(
+    data: Optional[ArrayLike] = None,
+    *,
+    Z: Optional[np.ndarray] = None,
+    condensed_distances: Optional[ArrayLike] = None,
+    labels: Optional[Sequence[str]] = None,
+    metric: str = "euclidean",
+    method: str = "ward",
+    color_threshold: Optional[float] = None,
+    link_color_func=None,
+    truncate_mode: Optional[str] = None,
+    p: int = 30,
+) -> DendrogramLayout:
+    """Build a validated :class:`DendrogramLayout` from one of three inputs.
+
+    Exactly one of ``data``, ``Z``, or ``condensed_distances`` should be
+    given:
+
+    - ``data``: an ``(n_observations, n_features)`` array of raw
+      observations. Pairwise distances (``metric``) and linkage
+      (``method``) are computed for you, mirroring what the original
+      ad hoc script did with ``pdist`` + ``linkage``.
+    - ``Z``: a precomputed linkage matrix (e.g. your own call to
+      ``scipy.cluster.hierarchy.linkage``, or ``R``'s ``hclust`` output
+      converted with ``scipy``-compatible tooling). Validated with
+      ``scipy.cluster.hierarchy.is_valid_linkage`` before use.
+    - ``condensed_distances``: a precomputed condensed distance vector
+      (as returned by ``scipy.spatial.distance.pdist``); ``method`` is
+      applied to it to obtain ``Z``.
+
+    Parameters
+    ----------
+    labels : sequence of str, optional
+        One label per leaf, in the same order as the rows of ``data``
+        (or the original observations behind ``Z`` /
+        ``condensed_distances``). Defaults to stringified indices.
+    color_threshold, link_color_func, truncate_mode, p
+        Passed straight through to ``scipy.cluster.hierarchy.dendrogram``;
+        see its docstring. Use ``color_threshold`` to have SciPy assign
+        per-cluster colors automatically (a common way to visually mark
+        clades below a chosen cut height).
+
+    Raises
+    ------
+    DendrofanError
+        If none or more than one of ``data``/``Z``/``condensed_distances``
+        is given, if a given ``Z`` fails SciPy's validity check, if
+        ``labels`` does not have one entry per leaf, or if the resulting
+        tree has fewer than 2 leaves (nothing meaningful to draw).
+    """
+    n_inputs_given = sum(x is not None for x in (data, Z, condensed_distances))
+    if n_inputs_given != 1:
+        raise ValueError(
+            "pass exactly one of `data`, `Z`, or `condensed_distances` "
+            f"(got {n_inputs_given})"
+        )
+
+    if data is not None:
+        data = np.asarray(data, dtype=float)
+        if data.ndim != 2:
+            raise ValueError("`data` must be a 2-D array (n_observations, n_features)")
+        if data.shape[0] < 2:
+            raise DegenerateTreeError(
+                f"need at least 2 observations to build a tree, got {data.shape[0]}"
+            )
+        condensed = pdist(data, metric=metric)
+        Z = _scipy_linkage(condensed, method=method)
+    elif condensed_distances is not None:
+        condensed = np.asarray(condensed_distances, dtype=float)
+        if not is_valid_y(condensed):
+            raise InvalidLinkageError(
+                "`condensed_distances` is not a valid condensed distance vector "
+                "(check its length matches n*(n-1)/2 for some integer n)"
+            )
+        Z = _scipy_linkage(condensed, method=method)
+    else:
+        Z = np.asarray(Z, dtype=float)
+        if not is_valid_linkage(Z):
+            raise InvalidLinkageError(
+                "`Z` is not a valid SciPy linkage matrix; see "
+                "scipy.cluster.hierarchy.is_valid_linkage for the required format"
+            )
+
+    n_leaves = Z.shape[0] + 1
+    if n_leaves < 2:
+        raise DegenerateTreeError("need at least 2 leaves to build a tree")
+
+    resolved_labels = _validate_labels(labels, n_leaves)
+
+    dendro = _scipy_dendrogram(
+        Z,
+        labels=resolved_labels,
+        no_plot=True,
+        color_threshold=color_threshold,
+        link_color_func=link_color_func,
+        truncate_mode=truncate_mode,
+        p=p,
+    )
+
+    return DendrogramLayout(
+        Z=Z,
+        icoord=np.asarray(dendro["icoord"], dtype=float),
+        dcoord=np.asarray(dendro["dcoord"], dtype=float),
+        leaves=list(dendro["leaves"]),
+        leaf_labels=list(dendro["ivl"]),
+        color_list=list(dendro["color_list"]),
+    )

dendrofan/exceptions.py

@@ -0,0 +1,17 @@
+"""Exceptions raised by dendrofan."""
+
+
+class DendrofanError(Exception):
+    """Base class for all errors raised by dendrofan."""
+
+
+class InvalidLinkageError(DendrofanError):
+    """Raised when a linkage matrix fails SciPy's own consistency checks."""
+
+
+class LabelMismatchError(DendrofanError):
+    """Raised when the number of labels does not match the number of leaves."""
+
+
+class DegenerateTreeError(DendrofanError):
+    """Raised when a tree has too few leaves to be drawn (n < 2)."""

dendrofan/geometry.py

@@ -0,0 +1,218 @@
+"""
+Core polar-coordinate geometry for circular ("fan") dendrograms.
+
+This module contains the one genuinely reusable idea behind a circular
+dendrogram: a pair of coordinate maps that take the rectangular
+coordinates produced by ``scipy.cluster.hierarchy.dendrogram`` --
+``icoord`` (leaf positions along x) and ``dcoord`` (linkage heights along
+y) -- and bend them onto an annulus.
+
+Everything else in dendrofan (clustering, styling, plotting) builds on
+top of :class:`PolarTransform`.
+"""
+from __future__ import annotations
+
+import dataclasses
+import math
+from typing import Callable, Tuple, Union
+
+import numpy as np
+
+RadiusScaleName = str  # "linear" or "sqrt"
+RadiusScale = Union[RadiusScaleName, Callable[[np.ndarray], np.ndarray]]
+
+
+@dataclasses.dataclass(frozen=True)
+class PolarTransform:
+    """Maps rectangular dendrogram coordinates onto an annulus.
+
+    A rectangular dendrogram, as produced by
+    ``scipy.cluster.hierarchy.dendrogram``, lives on a plane where the
+    x-axis enumerates leaves (evenly spaced, 10 units apart by SciPy's
+    convention) and the y-axis is the linkage/merge height, with 0 at
+    the leaves and increasing towards the root.
+
+    This class re-maps that plane onto polar coordinates:
+
+    - x (leaf position)  -> theta (angle), so leaves spread around a
+      circle instead of sitting on a line.
+    - y (linkage height) -> r (radius), so the root sits near the
+      centre and leaves sit on the outer rim (or the reverse, if
+      ``invert_radius=False``).
+
+    Parameters
+    ----------
+    x_min, x_max : float
+        The extent of the x-axis in the source rectangular dendrogram
+        (``icoord.min()`` / ``icoord.max()``).
+    y_max : float
+        The maximum linkage height in the source dendrogram
+        (``dcoord.max()``). If this is ``0`` (a degenerate tree where
+        every merge happens at height 0), the transform falls back to
+        placing every internal node at the outer radius instead of
+        raising a ZeroDivisionError.
+    start_angle : float, default 90
+        Angle, in degrees, of the *first* leaf, measured counter-
+        clockwise from the positive x-axis (standard math convention).
+        90 puts the first leaf pointing straight up, matching the
+        default orientation used by ``ape::plot.phylo(type = "fan")``.
+    span : float, default 360
+        Total angular extent, in degrees, that the leaves are spread
+        across. Use a value below 360 (e.g. 350) to leave an angular
+        gap between the first and last leaf, which is useful when
+        labels would otherwise collide at the seam -- this mirrors the
+        partial-fan idiom available in ``ape``.
+    clockwise : bool, default True
+        If True, leaves are laid out clockwise from ``start_angle``
+        (the conventional reading direction for circular dendrograms
+        and the ``ape`` default). If False, they are laid out counter-
+        clockwise.
+    inner_radius : float, default 0.0
+        Radius of the root (or of the centre, if ``inner_radius`` is 0).
+        A small positive value reproduces the central gap conventional
+        in ``ape``'s fan style and avoids a cluttered centre.
+    outer_radius : float, default 1.0
+        Radius of the leaves.
+    invert_radius : bool, default True
+        If True (default), y=0 (leaves) maps to ``outer_radius`` and
+        y=y_max (root) maps to ``inner_radius`` -- the usual dendrogram
+        reading, root at the centre. If False, the mapping is reversed
+        (root at the rim) -- rarely useful, provided for completeness.
+    radius_scale : {"linear", "sqrt"} or callable, default "linear"
+        How linkage height is mapped to radius.
+
+        - ``"linear"``: radius is a linear function of height. This
+          matches the original ad hoc script and is the correct choice
+          when the *radial distance* should be read quantitatively
+          (e.g. with a distance-scale ring).
+        - ``"sqrt"``: radius is proportional to the square root of the
+          (rescaled) height. Because the area of an annulus grows with
+          the square of its radius, a linear height mapping visually
+          compresses shallow, near-root merges into a tiny central
+          area and exaggerates the area given to merges near the rim.
+          The square-root mapping keeps the *area* allotted to a given
+          range of merge heights roughly constant across radii, which
+          is often more legible for trees with many leaves and a long
+          tail of shallow merges. This is a purely cosmetic remapping
+          and should not be used if radial distances will be read
+          quantitatively.
+        - a callable ``f(y_norm) -> r_norm`` mapping normalised height
+          in [0, 1] to normalised radius in [0, 1], for full control.
+
+    Notes
+    -----
+    All angles are handled internally in radians; degrees are only
+    used at the public boundary (``start_angle``, ``span``) because
+    that is what most users reason in.
+    """
+
+    x_min: float
+    x_max: float
+    y_max: float
+    start_angle: float = 90.0
+    span: float = 360.0
+    clockwise: bool = True
+    inner_radius: float = 0.0
+    outer_radius: float = 1.0
+    invert_radius: bool = True
+    radius_scale: RadiusScale = "linear"
+
+    def __post_init__(self) -> None:
+        if self.x_max < self.x_min:
+            raise ValueError("x_max must be >= x_min")
+        if self.y_max < 0:
+            raise ValueError("y_max must be >= 0")
+        if not (0 < self.span <= 360):
+            raise ValueError("span must be in (0, 360]")
+        if self.outer_radius <= self.inner_radius:
+            raise ValueError("outer_radius must be > inner_radius")
+        if self.inner_radius < 0:
+            raise ValueError("inner_radius must be >= 0")
+
+    # -- angle ---------------------------------------------------------
+
+    def theta(self, x):
+        """Map rectangular x-coordinate(s) (leaf axis) to angle(s), in radians."""
+        x = np.asarray(x, dtype=float)
+        x_range = self.x_max - self.x_min
+        if x_range == 0:
+            # A single leaf: park it at start_angle.
+            frac = np.zeros_like(x)
+        else:
+            frac = (x - self.x_min) / x_range
+        span_rad = math.radians(self.span)
+        start_rad = math.radians(self.start_angle)
+        signed_span = -span_rad if self.clockwise else span_rad
+        return start_rad + frac * signed_span
+
+    # -- radius ----------------------------------------------------------
+
+    def radius(self, y):
+        """Map rectangular y-coordinate(s) (linkage height) to radius/radii."""
+        y = np.asarray(y, dtype=float)
+        if self.y_max == 0:
+            # Degenerate tree: every merge happens at height 0. There is
+            # no meaningful radial ordering, so place every node at the
+            # leaf radius rather than dividing by zero.
+            y_norm = np.zeros_like(y)
+        else:
+            y_norm = np.clip(y / self.y_max, 0.0, 1.0)
+
+        r_norm = self._apply_radius_scale(y_norm)
+
+        if self.invert_radius:
+            r_norm = 1.0 - r_norm
+
+        return self.inner_radius + (self.outer_radius - self.inner_radius) * r_norm
+
+    def _apply_radius_scale(self, y_norm):
+        scale = self.radius_scale
+        if callable(scale):
+            return scale(y_norm)
+        if scale == "linear":
+            return y_norm
+        if scale == "sqrt":
+            return np.sqrt(y_norm)
+        raise ValueError(
+            f"radius_scale must be 'linear', 'sqrt', or a callable, got {scale!r}"
+        )
+
+    # -- combined --------------------------------------------------------
+
+    def to_cartesian(self, x, y):
+        """Map rectangular (x, y) dendrogram coordinates straight to (X, Y)."""
+        t = self.theta(x)
+        r = self.radius(y)
+        return r * np.cos(t), r * np.sin(t)
+
+
+def arc_points(transform, x_start, x_end, y, n_points=50):
+    """Cartesian points tracing a constant-radius arc between two leaf positions.
+
+    Used to draw the horizontal bar of a dendrogram merge (a straight
+    line in rectangular coordinates) as a properly curved arc once
+    bent onto the annulus.
+    """
+    xs = np.linspace(x_start, x_end, n_points)
+    ys = np.full(n_points, y)
+    return transform.to_cartesian(xs, ys)
+
+
+def radial_label_alignment(theta_rad: float) -> Tuple[float, str]:
+    """Rotation (degrees) and horizontal alignment for a label at angle ``theta_rad``.
+
+    Labels placed just outside the rim of a circular dendrogram should
+    read left-to-right when possible instead of upside down. This
+    returns the text rotation (in degrees, as expected by
+    ``matplotlib``'s ``rotation`` kwarg with ``rotation_mode="anchor"``)
+    and the horizontal alignment (``"left"`` or ``"right"``) so that
+    text on the left half of the circle is flipped 180 degrees and
+    right-aligned, keeping it upright and pointing away from the tree.
+    """
+    angle_deg = math.degrees(theta_rad) % 360.0
+    # Normalise to (-180, 180] for the upright/flipped test below.
+    signed_deg = angle_deg if angle_deg <= 180 else angle_deg - 360
+    if -90 <= signed_deg <= 90:
+        return signed_deg, "left"
+    flipped = signed_deg + 180 if signed_deg < 0 else signed_deg - 180
+    return flipped, "right"

dendrofan/plotting.py

@@ -0,0 +1,314 @@
+"""Public plotting API: draw a circular ("fan") dendrogram."""
+from __future__ import annotations
+
+import dataclasses
+from typing import Dict, List, Optional, Sequence, Tuple
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+
+from .clustering import ArrayLike, DendrogramLayout, build_layout
+from .geometry import PolarTransform, arc_points, radial_label_alignment
+from .styling import ColorMap, resolve_leaf_colors
+
+
+@dataclasses.dataclass
+class CircularDendrogramResult:
+    """Everything a caller might need to annotate a circular dendrogram further.
+
+    Attributes
+    ----------
+    fig, ax : matplotlib Figure / Axes
+        The figure and axes the tree was drawn on.
+    layout : DendrogramLayout
+        The rectangular-dendrogram layout the tree was built from.
+    transform : PolarTransform
+        The polar transform used, so callers can map their own extra
+        rectangular coordinates (or additional linkage heights) into
+        the same coordinate system, e.g. to add a scale ring with
+        :func:`dendrofan.annotations.add_scale_ring`.
+    leaf_theta : dict of {str: float}
+        Angle (radians) of each leaf label's centre, keyed by the
+        (possibly duplicated) display label as drawn. For unique
+        per-leaf angles regardless of label text, use ``leaf_theta_by_index``.
+    leaf_theta_by_index : list of float
+        Angle (radians) of each leaf, in the same left-to-right order
+        as ``layout.leaf_labels`` / ``layout.leaves``.
+    """
+
+    fig: Figure
+    ax: Axes
+    layout: DendrogramLayout
+    transform: PolarTransform
+    leaf_theta: Dict[str, float]
+    leaf_theta_by_index: List[float]
+
+
+def circular_dendrogram(
+    data: Optional[ArrayLike] = None,
+    *,
+    Z: Optional[np.ndarray] = None,
+    condensed_distances: Optional[ArrayLike] = None,
+    labels: Optional[Sequence[str]] = None,
+    metric: str = "euclidean",
+    method: str = "ward",
+    color_threshold: Optional[float] = None,
+    link_color_func=None,
+    truncate_mode: Optional[str] = None,
+    p: int = 30,
+    ax: Optional[Axes] = None,
+    figsize: Tuple[float, float] = (10, 10),
+    start_angle: float = 90.0,
+    span: float = 360.0,
+    clockwise: bool = True,
+    inner_radius: float = 0.12,
+    outer_radius: float = 1.0,
+    radius_scale: str = "linear",
+    branch_color: Optional[str] = "black",
+    branch_linewidth: float = 1.0,
+    n_arc_points: int = 50,
+    show_leaf_labels: bool = True,
+    label_colors: Optional[ColorMap] = None,
+    label_default_color: str = "black",
+    label_formatter=None,
+    label_fontsize: float = 10,
+    label_offset: float = 0.04,
+    label_fontstyle: str = "normal",
+    label_fontweight: str = "normal",
+    leaf_marker: Optional[str] = None,
+    leaf_marker_size: float = 20,
+) -> CircularDendrogramResult:
+    """Draw a circular ("fan"/"ape"-style) dendrogram.
+
+    This is the circular analogue of
+    ``scipy.cluster.hierarchy.dendrogram``: it takes the same kinds of
+    inputs (raw observations, a condensed distance vector, or a
+    precomputed linkage matrix), builds the same tree, and draws it
+    bent onto an annulus instead of a rectangle -- in the visual style
+    of ``ape::plot.phylo(type = "fan")`` in R (Paradis & Schliep, 2019),
+    computed and rendered entirely with SciPy and Matplotlib.
+
+    Exactly one of ``data``, ``Z``, or ``condensed_distances`` must be
+    given; see :func:`dendrofan.clustering.build_layout` for details on
+    each. All clustering/tree-building parameters
+    (``metric``, ``method``, ``color_threshold``, ``link_color_func``,
+    ``truncate_mode``, ``p``) are forwarded there unchanged.
+
+    Parameters
+    ----------
+    labels : sequence of str, optional
+        One label per leaf/observation. Defaults to stringified indices.
+    ax : matplotlib Axes, optional
+        Axes to draw on. If omitted, a new square figure is created.
+        The axes are always plain Cartesian (not a matplotlib polar
+        projection) so that label rotation, partial fans, and inward
+        roots are all under direct control; the polar math itself is
+        handled by :class:`dendrofan.geometry.PolarTransform` and
+        applied before anything is plotted.
+    figsize : (float, float), default (10, 10)
+        Figure size when ``ax`` is not given. Ignored if ``ax`` is given.
+    start_angle, span, clockwise, inner_radius, outer_radius, radius_scale
+        Forwarded to :class:`dendrofan.geometry.PolarTransform`; see
+        its docstring for the full explanation of each. In short:
+        ``span=350`` (instead of 360) opens a gap for labels at the
+        seam, and ``radius_scale="sqrt"`` trades quantitative radial
+        distance for better legibility on trees with many leaves.
+    branch_color : str, optional
+        Color for every branch. If ``None``, each merge is colored
+        according to SciPy's own ``color_list`` (meaningful only when
+        ``color_threshold`` or ``link_color_func`` is also set --
+        otherwise SciPy colors everything the same default color).
+    branch_linewidth : float, default 1.0
+        Line width for radial segments and arcs.
+    n_arc_points : int, default 50
+        Number of straight-line segments used to approximate each
+        curved merge arc. Higher values give smoother arcs at a small
+        performance cost; 50 is smooth even for large figures.
+    show_leaf_labels : bool, default True
+        If False, no leaf labels are drawn (useful when leaves will be
+        labeled by an external legend or when there are too many to
+        read individually).
+    label_colors : dict or callable, optional
+        Per-leaf label color; see :func:`dendrofan.styling.resolve_leaf_colors`.
+        Typically a ``{group_name: color}``-style dict combined with a
+        ``label -> group_name`` lookup, or directly a
+        ``{label: color}`` dict.
+    label_default_color : str, default "black"
+        Fallback color for labels not covered by ``label_colors``.
+    label_formatter : callable, optional
+        ``label -> display_string``, applied to each leaf label right
+        before drawing (e.g. to append an annotation such as
+        ``" (excl.)"``). The unmodified label is still used to look up
+        ``label_colors``.
+    label_fontsize, label_fontstyle, label_fontweight
+        Passed straight through to ``ax.text``.
+    label_offset : float, default 0.04
+        Radial gap between the outer rim (``outer_radius``) and the
+        start of each leaf label, in the same units as ``outer_radius``.
+    leaf_marker : str, optional
+        Matplotlib marker style (e.g. ``"o"``) drawn at each leaf tip.
+        ``None`` (default) draws no marker, matching the reference
+        figure style of the source manuscript.
+    leaf_marker_size : float, default 20
+        Marker size (``s`` in ``ax.scatter`` units), used only if
+        ``leaf_marker`` is not ``None``.
+
+    Returns
+    -------
+    CircularDendrogramResult
+        The figure/axes plus the layout and transform needed to add
+        further annotations (scale rings, sector highlights, etc. --
+        see :mod:`dendrofan.annotations`).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from dendrofan import circular_dendrogram
+    >>> rng = np.random.default_rng(0)
+    >>> data = rng.normal(size=(12, 5))
+    >>> result = circular_dendrogram(
+    ...     data,
+    ...     labels=[f"sample_{i}" for i in range(12)],
+    ...     span=350,               # leave a small gap at the seam
+    ...     inner_radius=0.15,
+    ... )
+    >>> result.fig.savefig("tree.png", dpi=200)
+    """
+    layout = build_layout(
+        data=data,
+        Z=Z,
+        condensed_distances=condensed_distances,
+        labels=labels,
+        metric=metric,
+        method=method,
+        color_threshold=color_threshold,
+        link_color_func=link_color_func,
+        truncate_mode=truncate_mode,
+        p=p,
+    )
+
+    transform = PolarTransform(
+        x_min=layout.x_min,
+        x_max=layout.x_max,
+        y_max=layout.y_max,
+        start_angle=start_angle,
+        span=span,
+        clockwise=clockwise,
+        inner_radius=inner_radius,
+        outer_radius=outer_radius,
+        radius_scale=radius_scale,
+    )
+
+    if ax is None:
+        fig, ax = plt.subplots(figsize=figsize)
+    else:
+        fig = ax.figure
+    ax.set_aspect("equal")
+
+    _draw_branches(
+        ax,
+        layout,
+        transform,
+        branch_color=branch_color,
+        branch_linewidth=branch_linewidth,
+        n_arc_points=n_arc_points,
+    )
+
+    leaf_colors = resolve_leaf_colors(
+        layout.leaf_labels, colors=label_colors, default=label_default_color
+    )
+
+    leaf_theta_by_index = _leaf_angles(layout, transform)
+
+    if leaf_marker is not None:
+        xs, ys = transform.to_cartesian(
+            np.array([_leaf_x(layout, i) for i in range(layout.n_leaves)]),
+            np.zeros(layout.n_leaves),
+        )
+        ax.scatter(xs, ys, s=leaf_marker_size, marker=leaf_marker, color=leaf_colors, zorder=3)
+
+    leaf_theta: Dict[str, float] = {}
+    if show_leaf_labels:
+        for i, (label, color, theta) in enumerate(
+            zip(layout.leaf_labels, leaf_colors, leaf_theta_by_index)
+        ):
+            display = label_formatter(label) if label_formatter else label
+            rotation, ha = radial_label_alignment(theta)
+            r_text = outer_radius + label_offset
+            x_txt, y_txt = r_text * np.cos(theta), r_text * np.sin(theta)
+            ax.text(
+                x_txt,
+                y_txt,
+                display,
+                rotation=rotation,
+                rotation_mode="anchor",
+                ha=ha,
+                va="center",
+                fontsize=label_fontsize,
+                fontstyle=label_fontstyle,
+                fontweight=label_fontweight,
+                color=color,
+            )
+            leaf_theta[label] = theta
+
+    margin = outer_radius * 0.85 + label_offset
+    limit = outer_radius + margin
+    ax.set_xlim(-limit, limit)
+    ax.set_ylim(-limit, limit)
+    ax.axis("off")
+
+    return CircularDendrogramResult(
+        fig=fig,
+        ax=ax,
+        layout=layout,
+        transform=transform,
+        leaf_theta=leaf_theta,
+        leaf_theta_by_index=leaf_theta_by_index,
+    )
+
+
+def _leaf_x(layout: DendrogramLayout, i: int) -> float:
+    """x-coordinate (rectangular dendrogram axis) of the i-th leaf, left to right.
+
+    SciPy always spaces leaves 10 units apart starting at 5 (5, 15, 25, ...);
+    this is reconstructed rather than assumed, by anchoring to the observed
+    ``icoord`` extent, so it stays correct under ``truncate_mode``.
+    """
+    if layout.n_leaves == 1:
+        return (layout.x_min + layout.x_max) / 2.0
+    step = (layout.x_max - layout.x_min) / (layout.n_leaves - 1)
+    return layout.x_min + i * step
+
+
+def _leaf_angles(layout: DendrogramLayout, transform: PolarTransform) -> List[float]:
+    xs = [_leaf_x(layout, i) for i in range(layout.n_leaves)]
+    return [float(transform.theta(x)) for x in xs]
+
+
+def _draw_branches(
+    ax: Axes,
+    layout: DendrogramLayout,
+    transform: PolarTransform,
+    *,
+    branch_color: Optional[str],
+    branch_linewidth: float,
+    n_arc_points: int,
+) -> None:
+    for row, (xs, ys) in enumerate(zip(layout.icoord, layout.dcoord)):
+        x1, x2, x3, x4 = xs
+        y1, y2, y3, y4 = ys
+        color = branch_color if branch_color is not None else layout.color_list[row]
+
+        # Left radial segment: from the left child up to the merge height.
+        xr, yr = transform.to_cartesian(np.array([x1, x2]), np.array([y1, y2]))
+        ax.plot(xr, yr, color=color, linewidth=branch_linewidth)
+
+        # Right radial segment: from the right child up to the merge height.
+        xr, yr = transform.to_cartesian(np.array([x4, x3]), np.array([y4, y3]))
+        ax.plot(xr, yr, color=color, linewidth=branch_linewidth)
+
+        # Arc joining the two children at the (constant) merge height.
+        xr, yr = arc_points(transform, x2, x3, y2, n_points=n_arc_points)
+        ax.plot(xr, yr, color=color, linewidth=branch_linewidth)

dendrofan/styling.py

@@ -0,0 +1,67 @@
+"""Color and label-placement helpers for circular dendrograms."""
+from __future__ import annotations
+
+from typing import Callable, Dict, List, Optional, Sequence, Tuple, Union
+
+ColorMap = Union[Dict[str, str], Callable[[str], str]]
+
+
+def resolve_leaf_colors(
+    leaf_labels: Sequence[str],
+    colors: Optional[ColorMap] = None,
+    default: str = "black",
+) -> List[str]:
+    """Resolve a per-leaf color for each label in ``leaf_labels``.
+
+    Parameters
+    ----------
+    leaf_labels : sequence of str
+        Leaf labels, in left-to-right (or any) order -- one color is
+        produced per entry, in the same order.
+    colors : dict or callable, optional
+        - dict mapping label -> color. Labels missing from the dict
+          fall back to ``default`` rather than raising, since dendrograms
+          routinely mix "classified" and "unclassified" leaves (e.g. the
+          excluded stations in the source manuscript).
+        - callable ``label -> color``.
+        - ``None``: every leaf gets ``default``.
+    default : str, default "black"
+        Fallback color for labels not covered by ``colors``.
+
+    Returns
+    -------
+    list of str
+        One color per entry of ``leaf_labels``.
+    """
+    if colors is None:
+        return [default] * len(leaf_labels)
+    if callable(colors):
+        return [colors(label) for label in leaf_labels]
+    return [colors.get(label, default) for label in leaf_labels]
+
+
+def legend_handles(
+    color_map: Dict[str, str], marker: str = "s", markersize: float = 10
+) -> Tuple[list, list]:
+    """Build ``(handles, labels)`` for ``ax.legend()`` from a ``{group: color}`` map.
+
+    Groups are emitted in the order given by ``color_map`` (a plain
+    ``dict`` preserves insertion order in Python 3.7+), so callers
+    control legend ordering by controlling dict construction order.
+    """
+    from matplotlib.lines import Line2D
+
+    handles = [
+        Line2D(
+            [0],
+            [0],
+            marker=marker,
+            linestyle="",
+            markerfacecolor=color,
+            markeredgecolor=color,
+            markersize=markersize,
+        )
+        for color in color_map.values()
+    ]
+    labels = list(color_map.keys())
+    return handles, labels

dendrofan-0.1.1.dist-info/METADATA

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: dendrofan
+Version: 0.1.1
+Summary: Circular ("fan") dendrograms for Python, in the visual style of R's ape package
+Author: Rafael Magallanes Quintanar
+License: MIT
+Project-URL: Homepage, https://github.com/tiquis/dendrofan
+Project-URL: Issues, https://github.com/tiquis/dendrofan/issues
+Keywords: dendrogram,hierarchical-clustering,circular-plot,fan-plot,phylogenetics,data-visualization,scipy,matplotlib
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7
+Requires-Dist: matplotlib>=3.4
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-mpl; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+# dendrofan
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.21251841.svg)](https://doi.org/10.5281/zenodo.21251841)
+
+Circular ("fan") dendrograms for Python, in the visual style of R's
+[`ape`](https://cran.r-project.org/package=ape) package
+(`plot.phylo(type = "fan")`, Paradis & Schliep, 2019) — computed and
+rendered entirely with NumPy, SciPy, and Matplotlib. No R dependency,
+no reimplementation of clustering.
+
+## Why this exists
+
+`scipy.cluster.hierarchy` has no circular/fan layout. The usual
+workaround is a one-off script: call
+`scipy.cluster.hierarchy.dendrogram(..., no_plot=True)`, take its
+rectangular `icoord`/`dcoord` output, and manually re-project it into
+polar coordinates with Matplotlib. That works for one figure, but it
+tends to:
+
+- assume a full 360° circle with no gap for labels at the seam,
+- divide by `dcoord.max()` without checking for a degenerate,
+  all-zero-height tree,
+- hardcode SciPy's 10-units-per-leaf spacing convention,
+- have no story for trees with 1 or 2 leaves,
+- mix clustering, geometry, and plotting into a single script, so
+  none of it is reusable for the next dataset.
+
+dendrofan factors the actually-reusable idea — the rectangular-to-polar
+coordinate transform — into a small, tested, documented library, and
+builds a real plotting API on top of it.
+
+## Install
+
+```bash
+pip install -e .          # from a source checkout
+pip install -e ".[dev]"   # + pytest, for running the test suite
+```
+
+## Quick start
+
+```python
+import numpy as np
+from dendrofan import circular_dendrogram
+
+rng = np.random.default_rng(0)
+data = rng.normal(size=(20, 6))
+labels = [f"sample_{i:02d}" for i in range(20)]
+
+result = circular_dendrogram(
+    data,
+    labels=labels,
+    method="ward",       # forwarded to scipy.cluster.hierarchy.linkage
+    span=350,             # leave a small angular gap at the seam
+    inner_radius=0.15,    # small central gap, ape's fan style
+)
+result.fig.savefig("tree.png", dpi=200, bbox_inches="tight")
+```
+
+`circular_dendrogram` accepts the same three kinds of input as SciPy's
+own `dendrogram`: raw observations (`data=...`), a precomputed linkage
+matrix (`Z=...`), or a precomputed condensed distance vector
+(`condensed_distances=...`).
+
+See [`examples/quickstart.py`](examples/quickstart.py) and
+[`examples/reproduce_station_dendrogram.py`](examples/reproduce_station_dendrogram.py)
+(a fully worked, colored-by-group example) for more.
+
+## What it handles that the ad hoc version didn't
+
+| Case | Ad hoc script | dendrofan |
+|---|---|---|
+| Angular gap at the seam (for label room) | not supported (full circle only) | `span=350` (or any value `<= 360`) |
+| All-merge-heights-equal-zero tree | `ZeroDivisionError` / silent NaNs | falls back to placing all nodes at the leaf radius |
+| 1 or 2 leaves | untested, breaks silently | validated; raises `DegenerateTreeError` for < 2, works for 2 |
+| Mismatched label count | silent misalignment | raises `LabelMismatchError` |
+| Invalid linkage matrix / distance vector | undefined behavior | raises `InvalidLinkageError` before plotting |
+| Root at centre vs. rim, radius scale | hardcoded linear, root-at-centre | `inner_radius`/`outer_radius`/`invert_radius`, plus optional `"sqrt"` area-preserving radius scale |
+| Per-clade coloring | manual, one-off | `color_threshold`/`link_color_func` forwarded to SciPy, or a `label_colors` dict/callable |
+| Scale reference / clade highlighting | not present | `dendrofan.annotations.add_scale_ring`, `highlight_sector` |
+| Reuse across datasets | copy-paste the script | one function call |
+
+## API overview
+
+- `dendrofan.circular_dendrogram(...)` — the main entry point; draws
+  the tree and returns a `CircularDendrogramResult` (figure, axes,
+  layout, and the `PolarTransform` used, for further annotation).
+- `dendrofan.geometry.PolarTransform` — the reusable rectangular-to-polar
+  coordinate map, if you want to bend your own geometry onto the same
+  annulus (e.g. a custom decoration).
+- `dendrofan.clustering.build_layout(...)` — validated wrapper around
+  `scipy.cluster.hierarchy.linkage` / `dendrogram`, decoupled from
+  plotting.
+- `dendrofan.styling.resolve_leaf_colors`, `legend_handles` — color and
+  legend helpers.
+- `dendrofan.annotations.add_scale_ring`, `highlight_sector` — optional
+  decorations (a distance-reference ring; shaded clade sectors).
+
+Every public function and class has a full docstring; `help(...)` in a
+Python session is the fastest way to see the complete parameter
+reference.
+
+## Scope
+
+dendrofan draws circular dendrograms from hierarchical clustering
+(SciPy linkage matrices) — it does not parse Newick/phylogenetic tree
+files or handle unequal-tip-depth phylogenies the way `ape` itself
+does. If you need that, `ape` (R) or `ete3`/`Bio.Phylo` (Python) are a
+better fit; dendrofan specifically fills the "I have a SciPy
+dendrogram and want it circular" gap.
+
+## Testing
+
+```bash
+pytest
+```
+
+The test suite specifically exercises the edge cases listed above
+(degenerate trees, mismatched labels, invalid linkage matrices, partial
+spans, single/two-leaf trees).
+
+## Citation
+
+If you use dendrofan in a manuscript, please cite the software itself
+via its Zenodo DOI (see [`CITATION.cff`](CITATION.cff), or use GitHub's
+"Cite this repository" button):
+
+> Magallanes Quintanar, R. (2026). dendrofan v0.1.0 [Software]. Zenodo.
+> https://doi.org/10.5281/zenodo.21251841
+
+Please also cite the underlying methods it wraps:
+
+- Virtanen, P. et al. (2020). SciPy 1.0: fundamental algorithms for
+  scientific computing in Python. *Nature Methods*, 17, 261-272.
+  *(hierarchical clustering / linkage, which dendrofan builds on)*
+- Paradis, E. & Schliep, K. (2019). ape 5.0: an environment for modern
+  phylogenetics and evolutionary analyses in R. *Bioinformatics*,
+  35(3), 526-528. *(for the fan-plot visual convention dendrofan follows)*
+
+## License
+
+MIT — see [LICENSE](LICENSE).

dendrofan-0.1.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+dendrofan/__init__.py,sha256=H1Mfa-_VWHTwytHcDp5oVniZd7sWQQVLcq9u083I39c,2265
+dendrofan/_version.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+dendrofan/annotations.py,sha256=t9rG79eI9KRtHt-o0x2mCLrcppnPSZ5uyJry9dL1RN8,3649
+dendrofan/clustering.py,sha256=DrOZiKEuj-TT_xxyKIN6WhrqOLNldXvafor1e0HHY9Y,7191
+dendrofan/exceptions.py,sha256=JrSZwNZA_ElmX4scW2ep8nSPhNpkraTgRe1-ffNjtac,490
+dendrofan/geometry.py,sha256=bpfBDmJIq_vMjcM6BFtWGAFGDSGy3I0cm9yr2uHOUtA,9256
+dendrofan/plotting.py,sha256=4JN2aSL5lhoGEnORVy6hw-WKMFKGXSf7kABLGkPmDxs,12115
+dendrofan/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dendrofan/styling.py,sha256=MhiHs7UamW9Yqmg2Jw2nIYc1rIPe9i8ZzhZT7Yz4U3w,2227
+dendrofan-0.1.1.dist-info/licenses/LICENSE,sha256=uE3J7uh7-vMXpGN6xUIOLTQ8KSAt5OWvh8pHNWKjSBc,1079
+dendrofan-0.1.1.dist-info/METADATA,sha256=B7f5qGD9wAwAt8crDlj6wa-nQMxEAvOTefDfJzIiOY4,7090
+dendrofan-0.1.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+dendrofan-0.1.1.dist-info/top_level.txt,sha256=KmNquF3hQPPg44xSqscT6pDkVern5jU94QG4o_KKREg,10
+dendrofan-0.1.1.dist-info/RECORD,,

dendrofan-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dendrofan-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dendrofan contributors
+
+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.

dendrofan-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+dendrofan