phylustrator 0.1.0__tar.gz

phylustrator-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adrián A. Davín
+
+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.

phylustrator-0.1.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: phylustrator
+Version: 0.1.0
+Summary: A composable plotter for evolutionary figures: phylogenetic trees, genomes, synteny and alignments
+Author-email: "Adrian A. Davin" <aaredav@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/AADavin/Phylustrator
+Project-URL: Documentation, https://github.com/AADavin/Phylustrator#readme
+Project-URL: Repository, https://github.com/AADavin/Phylustrator
+Project-URL: Issues, https://github.com/AADavin/Phylustrator/issues
+Project-URL: Changelog, https://github.com/AADavin/Phylustrator/blob/main/CHANGELOG.md
+Keywords: phylogenetics,visualization,tree,biology,evolution,svg
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: drawsvg
+Provides-Extra: export
+Requires-Dist: cairosvg>=2.5; extra == "export"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.3; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0; extra == "dev"
+Requires-Dist: ete3; extra == "dev"
+Requires-Dist: cairosvg>=2.5; extra == "dev"
+Dynamic: license-file
+
+# Phylustrator
+
+A small, composable plotter for evolutionary figures. Two domains share one grammar: **`ph.trees`**
+plots phylogenetic trees and **`ph.genomes`** plots genomes, synteny and alignments. Start a figure,
+add layers with `+`, and save it to SVG, PDF, or PNG.
+
+![A 100-tip tree with branches coloured by a Brownian-motion trait](docs/img/tree.png)
+
+## Install
+
+```bash
+pip install git+https://github.com/AADavin/Phylustrator
+```
+
+SVG output needs nothing else; for PDF/PNG also install `cairosvg` (`pip install cairosvg`).
+
+## Trees
+
+```python
+import phylustrator as ph
+
+tree = ph.trees.loads("((((Human:6,Chimp:6)a:2,Gorilla:8)b:3,Orang:11)c:5,Gibbon:16)root;")
+brain = {"Human": 1350, "Chimp": 400, "Gorilla": 500, "Orang": 400, "Gibbon": 100,
+         "a": 650, "b": 560, "c": 500, "root": 470}
+
+(ph.trees.plot(tree)
+ + ph.trees.color_branches(brain)
+ + ph.trees.tip_labels()
+ + ph.trees.colorbar("brain size (cc)")
+ + ph.trees.time_axis("million years")).save("tree.png")
+```
+
+That is the whole idea: `plot(tree)` starts a figure and each `+ layer` adds one decoration.
+
+- **Layouts** — `rectangular` (default), `radial`, `unrooted`.
+- **Layers** — `color_branches`, `color_history`, `tip_labels`, `node_labels`, `tip_track`,
+  `branch_events`, `colorbar`, `legend`, `time_axis`, `time_marker`, `scale_bar`, `note`,
+  `highlight_clade`.
+
+## Genomes
+
+The same grammar, for genome maps. Plot a genome as a line or a ring, colour genes by family or
+strand, link two genomes with synteny ribbons, or set a copy-number heatmap / alignment beside a tree.
+
+```python
+import phylustrator as ph
+
+G = ph.genomes.read_gff("genome.gff")           # {name: Genome}
+genome = next(iter(G.values()))
+(ph.genomes.plot(genome, layout="circular", coordinates="nucleotide")
+ + ph.genomes.genes(by="strand")
+ + ph.genomes.position_axis()).save("ring.png")
+```
+
+- **Layouts** — `linear`, `circular`, and `stack` (one genome per row, for synteny).
+- **Layers** — `genes`, `synteny`, `highlight`, `position_axis`.
+- **Panels** — `heatmap`, `alignment`, placed next to a tree with `ph.beside(tree, panel)`.
+
+## ZOMBI2 I/O
+
+`ph.zombi` reads the output of the [ZOMBI2](https://github.com/AADavin/zombi2) genome-evolution
+simulator into the data models above — kept in one clearly-separated layer so the core stays
+format-agnostic:
+
+```python
+import phylustrator as ph
+
+G = ph.zombi.read_genomes("run/genomes")        # {lineage: Genome}
+M = ph.zombi.read_profiles("run")               # family x genome copy-number Matrix
+aln = ph.zombi.read_alignment("run", family=0)  # Alignment keyed by genome
+tree = ph.zombi.read_species_tree("run")        # a Tree
+```
+
+## Command line
+
+`phyl` is a one-shot tree viewer — hand it a Newick file:
+
+```bash
+phyl tree.nwk                 # render to a temporary PDF and open it
+phyl tree.nwk -o fig.svg      # save instead (format from the extension: .svg / .pdf / .png)
+phyl tree.nwk --radial --no-labels
+```
+
+Flags: `--layout {rectangular,radial,unrooted}` (or `--radial` / `--unrooted`), `--no-labels`,
+`--node-labels`, `--no-stem`, `--no-open`. Colouring and everything else live in the Python API.
+
+## Dependencies
+
+Only `drawsvg` (plus `cairosvg` for PDF/PNG). No `ete3`, no `matplotlib`.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

phylustrator-0.1.0/README.md

@@ -0,0 +1,93 @@
+# Phylustrator
+
+A small, composable plotter for evolutionary figures. Two domains share one grammar: **`ph.trees`**
+plots phylogenetic trees and **`ph.genomes`** plots genomes, synteny and alignments. Start a figure,
+add layers with `+`, and save it to SVG, PDF, or PNG.
+
+![A 100-tip tree with branches coloured by a Brownian-motion trait](docs/img/tree.png)
+
+## Install
+
+```bash
+pip install git+https://github.com/AADavin/Phylustrator
+```
+
+SVG output needs nothing else; for PDF/PNG also install `cairosvg` (`pip install cairosvg`).
+
+## Trees
+
+```python
+import phylustrator as ph
+
+tree = ph.trees.loads("((((Human:6,Chimp:6)a:2,Gorilla:8)b:3,Orang:11)c:5,Gibbon:16)root;")
+brain = {"Human": 1350, "Chimp": 400, "Gorilla": 500, "Orang": 400, "Gibbon": 100,
+         "a": 650, "b": 560, "c": 500, "root": 470}
+
+(ph.trees.plot(tree)
+ + ph.trees.color_branches(brain)
+ + ph.trees.tip_labels()
+ + ph.trees.colorbar("brain size (cc)")
+ + ph.trees.time_axis("million years")).save("tree.png")
+```
+
+That is the whole idea: `plot(tree)` starts a figure and each `+ layer` adds one decoration.
+
+- **Layouts** — `rectangular` (default), `radial`, `unrooted`.
+- **Layers** — `color_branches`, `color_history`, `tip_labels`, `node_labels`, `tip_track`,
+  `branch_events`, `colorbar`, `legend`, `time_axis`, `time_marker`, `scale_bar`, `note`,
+  `highlight_clade`.
+
+## Genomes
+
+The same grammar, for genome maps. Plot a genome as a line or a ring, colour genes by family or
+strand, link two genomes with synteny ribbons, or set a copy-number heatmap / alignment beside a tree.
+
+```python
+import phylustrator as ph
+
+G = ph.genomes.read_gff("genome.gff")           # {name: Genome}
+genome = next(iter(G.values()))
+(ph.genomes.plot(genome, layout="circular", coordinates="nucleotide")
+ + ph.genomes.genes(by="strand")
+ + ph.genomes.position_axis()).save("ring.png")
+```
+
+- **Layouts** — `linear`, `circular`, and `stack` (one genome per row, for synteny).
+- **Layers** — `genes`, `synteny`, `highlight`, `position_axis`.
+- **Panels** — `heatmap`, `alignment`, placed next to a tree with `ph.beside(tree, panel)`.
+
+## ZOMBI2 I/O
+
+`ph.zombi` reads the output of the [ZOMBI2](https://github.com/AADavin/zombi2) genome-evolution
+simulator into the data models above — kept in one clearly-separated layer so the core stays
+format-agnostic:
+
+```python
+import phylustrator as ph
+
+G = ph.zombi.read_genomes("run/genomes")        # {lineage: Genome}
+M = ph.zombi.read_profiles("run")               # family x genome copy-number Matrix
+aln = ph.zombi.read_alignment("run", family=0)  # Alignment keyed by genome
+tree = ph.zombi.read_species_tree("run")        # a Tree
+```
+
+## Command line
+
+`phyl` is a one-shot tree viewer — hand it a Newick file:
+
+```bash
+phyl tree.nwk                 # render to a temporary PDF and open it
+phyl tree.nwk -o fig.svg      # save instead (format from the extension: .svg / .pdf / .png)
+phyl tree.nwk --radial --no-labels
+```
+
+Flags: `--layout {rectangular,radial,unrooted}` (or `--radial` / `--unrooted`), `--no-labels`,
+`--node-labels`, `--no-stem`, `--no-open`. Colouring and everything else live in the Python API.
+
+## Dependencies
+
+Only `drawsvg` (plus `cairosvg` for PDF/PNG). No `ete3`, no `matplotlib`.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

phylustrator-0.1.0/pyproject.toml

@@ -0,0 +1,73 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "phylustrator"
+version = "0.1.0"
+description = "A composable plotter for evolutionary figures: phylogenetic trees, genomes, synteny and alignments"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+  {name = "Adrian A. Davin", email = "aaredav@gmail.com"},
+]
+keywords = ["phylogenetics", "visualization", "tree", "biology", "evolution", "svg"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "Topic :: Scientific/Engineering :: Visualization",
+    "Typing :: Typed",
+]
+dependencies = [
+    "drawsvg",
+]
+
+[project.urls]
+Homepage = "https://github.com/AADavin/Phylustrator"
+Documentation = "https://github.com/AADavin/Phylustrator#readme"
+Repository = "https://github.com/AADavin/Phylustrator"
+Issues = "https://github.com/AADavin/Phylustrator/issues"
+Changelog = "https://github.com/AADavin/Phylustrator/blob/main/CHANGELOG.md"
+
+[project.optional-dependencies]
+export = ["cairosvg>=2.5"]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "ruff>=0.3",
+    "mypy>=1.0",
+    "pre-commit>=3.0",
+    "ete3",       # test-only: the differential oracle for the Newick parser
+    "cairosvg>=2.5",
+]
+
+[project.scripts]
+phyl = "phylustrator.cli:main"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py", "tests_*.py"]
+addopts = "-v --tb=short"
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true
+
+[tool.ruff]
+target-version = "py310"
+line-length = 120
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
+ignore = ["E501"]

phylustrator-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

phylustrator-0.1.0/src/phylustrator/__init__.py

@@ -0,0 +1,29 @@
+"""Phylustrator — a lean, composable plotter for phylogenetics: **trees** and **genomes**.
+
+Two domains, one grammar (``plot(x) + layer + …``), one shared drawing backend:
+
+    import phylustrator as ph
+
+    # trees
+    tree = ph.trees.loads("((A:1,B:1)C:2,D:3)R;")
+    (ph.trees.plot(tree) + ph.trees.color_branches(vals) + ph.trees.time_axis()).save("tree.pdf")
+
+    # genomes
+    G = ph.zombi.read_genomes("run")
+    (ph.genomes.plot(G["n12"], layout="circular") + ph.genomes.genes(by="family")).save("ring.png")
+
+    # bridge: a matrix beside a tree
+    ph.beside(ph.trees.plot(tree) + ph.trees.tip_labels(), ph.genomes.heatmap(ph.zombi.read_profiles("run")))
+
+``ph.zombi`` is the only ZOMBI2-format-aware module; ``trees`` / ``genomes`` are general.
+"""
+
+from __future__ import annotations
+
+from . import genomes, trees, zombi
+from .compose import Composite, beside
+from .style import Style
+
+__version__ = "0.1.0"
+
+__all__ = ["trees", "genomes", "zombi", "beside", "Composite", "Style", "__version__"]

phylustrator-0.1.0/src/phylustrator/__main__.py

@@ -0,0 +1,5 @@
+"""``python -m phylustrator`` → the ``phyl`` command-line viewer."""
+
+from .cli import main
+
+raise SystemExit(main())

phylustrator-0.1.0/src/phylustrator/cli.py

@@ -0,0 +1,85 @@
+"""``phyl`` — a one-shot tree viewer.
+
+    phyl tree.nwk                 # render to a temporary PDF and open it
+    phyl tree.nwk -o fig.svg      # save instead (format from the extension)
+    phyl tree.nwk --radial --no-labels
+
+Deliberately tiny: it reads a Newick file, draws it, and shows or saves it. Anything richer
+(colouring, tracks, custom styles) lives in the Python API.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+from . import __version__
+from .trees import node_labels, plot, read, scale_bar, tip_labels, time_axis
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="phyl", description="Draw a phylogenetic tree from a Newick file.")
+    p.add_argument("tree", help="Newick tree file")
+    p.add_argument("-o", "--output", metavar="FILE",
+                   help="save here (.svg/.pdf/.png); default: a temporary PDF, opened")
+    p.add_argument("--layout", choices=["rectangular", "radial", "unrooted"], default="rectangular")
+    p.add_argument("--radial", action="store_const", const="radial", dest="layout",
+                   help="shortcut for --layout radial")
+    p.add_argument("--unrooted", action="store_const", const="unrooted", dest="layout",
+                   help="shortcut for --layout unrooted")
+    p.add_argument("--no-labels", action="store_true", help="hide tip labels")
+    p.add_argument("--node-labels", action="store_true", help="also label internal nodes")
+    p.add_argument("--no-stem", action="store_true", help="start at the crown (hide the root stem)")
+    p.add_argument("--no-open", action="store_true", help="do not open the temporary file")
+    p.add_argument("-V", "--version", action="version", version=f"phyl {__version__}")
+    return p
+
+
+def _open(path: Path) -> None:
+    try:
+        if sys.platform == "darwin":
+            subprocess.run(["open", str(path)], check=False)
+        elif sys.platform.startswith("win"):
+            os.startfile(str(path))  # type: ignore[attr-defined]  # noqa: S606
+        else:
+            subprocess.run(["xdg-open", str(path)], check=False)
+    except OSError:
+        pass  # opening is a convenience; the path is printed regardless
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _parser()
+    args = parser.parse_args(argv)
+
+    try:
+        tree = read(args.tree)
+    except (FileNotFoundError, ValueError) as exc:
+        parser.error(str(exc))
+
+    figure = plot(tree, layout=args.layout, stem=not args.no_stem)
+    if not args.no_labels:
+        figure = figure + tip_labels()
+    if args.node_labels:
+        figure = figure + node_labels()
+    figure = figure + (time_axis() if args.layout == "rectangular" else scale_bar())
+
+    if args.output:
+        out = figure.save(args.output)
+        print(out)
+        return 0
+
+    # No -o: a genuinely throwaway file in the system temp dir.
+    tmp = Path(tempfile.mkdtemp(prefix="phyl_")) / "tree.pdf"
+    out = figure.save(tmp)  # may return a .svg sibling if cairosvg is absent
+    print(out)
+    if not args.no_open:
+        _open(out)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

phylustrator-0.1.0/src/phylustrator/color.py

@@ -0,0 +1,92 @@
+"""Colour — colormaps for continuous values, palettes for categories, and normalisation.
+
+Matplotlib-free: the viridis ramp is a small embedded lookup table sampled by interpolation, and the
+categorical palette is Paul Tol's colour-blind-safe "bright" set.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Callable, Iterable
+
+# viridis, 16 anchor colours (R, G, B in 0–255), sampled evenly from matplotlib.
+_COLORMAPS: dict[str, list[tuple[int, int, int]]] = {
+    "viridis": [
+        (68, 1, 84), (72, 26, 108), (71, 47, 125), (65, 68, 135),
+        (57, 86, 140), (49, 104, 142), (42, 120, 142), (35, 136, 142),
+        (31, 152, 139), (34, 168, 132), (53, 183, 121), (84, 197, 104),
+        (122, 209, 81), (165, 219, 54), (210, 226, 27), (253, 231, 37),
+    ],
+}
+
+# Paul Tol "bright" — distinct and colour-blind-safe.
+_PALETTE = ["#4477AA", "#EE6677", "#228833", "#CCBB44", "#66CCEE", "#AA3377", "#BBBBBB"]
+
+
+def to_hex(rgb: tuple[float, float, float]) -> str:
+    return "#{:02x}{:02x}{:02x}".format(*(int(max(0, min(255, round(c)))) for c in rgb))
+
+
+def colormap(name: str = "viridis") -> Callable[[float], tuple[int, int, int]]:
+    """Return a sampler ``t in [0, 1] -> (R, G, B)`` that interpolates the named colormap."""
+    anchors = _colormap_anchors(name)
+    n = len(anchors)
+
+    def sample(t: float) -> tuple[int, int, int]:
+        t = max(0.0, min(1.0, float(t)))
+        pos = t * (n - 1)
+        i = int(math.floor(pos))
+        if i >= n - 1:
+            return anchors[-1]
+        frac = pos - i
+        a, b = anchors[i], anchors[i + 1]
+        return tuple(a[k] + (b[k] - a[k]) * frac for k in range(3))
+
+    return sample
+
+
+def colormap_hex(name: str = "viridis") -> list[str]:
+    """The colormap's anchor colours as hex — for a gradient bar."""
+    return [to_hex(rgb) for rgb in _colormap_anchors(name)]
+
+
+def _colormap_anchors(name: str) -> list[tuple[int, int, int]]:
+    anchors = _COLORMAPS.get(name.lower())
+    if anchors is None:
+        raise ValueError(f"unknown colormap {name!r}; available: {sorted(_COLORMAPS)}")
+    return anchors
+
+
+def palette(labels: Iterable) -> dict:
+    """A ``{label: hex colour}`` map over ``labels`` (sorted for stability), from the bright set."""
+    ordered = sorted(set(labels), key=str)
+    return {label: _PALETTE[i % len(_PALETTE)] for i, label in enumerate(ordered)}
+
+
+def normalize(values: Iterable[float]) -> tuple[float, float, Callable[[float], float]]:
+    """Return ``(vmin, vmax, to_unit)`` where ``to_unit(v)`` maps ``[vmin, vmax] -> [0, 1]``."""
+    nums = [float(v) for v in values]
+    vmin, vmax = min(nums), max(nums)
+    span = (vmax - vmin) or 1.0
+    return vmin, vmax, lambda v: (float(v) - vmin) / span
+
+
+def _is_number(v) -> bool:
+    return isinstance(v, (int, float)) and not isinstance(v, bool)
+
+
+def map_values(values: dict, *, cmap: str = "viridis",
+               palette: dict | None = None) -> tuple[dict, dict]:
+    """Turn ``{key: value}`` into ``({key: hex colour}, scale)``, dispatching on the data: numbers get
+    the colormap (and a ``continuous`` scale for a colour bar), labels get a palette (and a
+    ``categorical`` scale for a legend). ``scale`` is ``None`` if there is nothing to colour."""
+    present = {k: v for k, v in values.items() if v is not None}
+    if not present:
+        return {}, None
+    if all(_is_number(v) for v in present.values()):
+        vmin, vmax, to_unit = normalize(present.values())
+        sample = colormap(cmap)
+        colors = {k: to_hex(sample(to_unit(v))) for k, v in present.items()}
+        return colors, {"kind": "continuous", "vmin": vmin, "vmax": vmax, "cmap": cmap}
+    pal = palette or globals()["palette"](present.values())
+    return {k: pal[v] for k, v in present.items()}, {"kind": "categorical", "palette": pal}

phylustrator-0.1.0/src/phylustrator/compose.py

@@ -0,0 +1,61 @@
+"""Composition — put a Genustrator panel beside a Phylustrator tree, rows lined up with the tips.
+
+``beside(tree, panel)`` takes a **Phylustrator** figure (the phylogeny — Phylustrator draws it, we do
+not redraw it) and a panel (``heatmap`` / ``alignment``). It asks the tree for its tip pixel positions
+(``Figure.geometry``), renders the tree into the left column, and draws the panel to the right with
+each row at its tip's ``y`` — so a genome's row sits exactly on its leaf.
+"""
+
+from __future__ import annotations
+
+from .render import Canvas
+from .style import Style
+
+
+class Composite:
+    """The rendered composite; save like any figure."""
+
+    def __init__(self, canvas: Canvas) -> None:
+        self._canvas = canvas
+
+    def as_svg(self) -> str:
+        return self._canvas.as_svg()
+
+    def save(self, path):
+        return self._canvas.save(path)
+
+
+def beside(tree, panel, *, width: float = 1100.0, height: float | None = None,
+           tree_fraction: float = 0.4, gap: float = 18.0, pad: float = 34.0,
+           footer: float = 0.0, background: str = "white") -> Composite:
+    """Render Phylustrator ``tree`` on the left and ``panel`` on the right, rows aligned to the tips.
+
+    ``tree_fraction`` is the share of the width given to the tree column (the rest, minus ``gap`` and
+    ``pad``, holds the panel). ``footer`` reserves blank height below the rows (for a panel's colour
+    key). Rows are matched to tips by label and drawn in the tree's tip order. Needs ``cairosvg``."""
+    try:
+        import cairosvg
+    except ImportError as exc:                       # pragma: no cover
+        raise RuntimeError("genustrator.beside needs cairosvg (pip install genustrator[export]) "
+                           "to place the tree into the composite") from exc
+
+    n_tips = len(tree.tree.leaves)
+    # per-tip row height eases from ~44px (few tips) down to ~24px (many), so 25-40 rows stay sane
+    row_px = max(24.0, 46.0 - 0.55 * n_tips)
+    H = height if height is not None else max(260.0, 70.0 + row_px * n_tips) + footer
+    tree_w = round(width * tree_fraction)
+    tree_h = H - footer                              # tips fill the area above the footer
+
+    sized = tree.with_size(tree_w, tree_h)
+    geom = sized.geometry()
+    png = cairosvg.svg2png(bytestring=sized.as_svg().encode(),
+                           output_width=int(tree_w * 2), output_height=int(tree_h * 2))
+
+    canvas = Canvas(Style(width=width, height=H, margin=0, background=background), (0.0, 1.0), (0.0, 1.0))
+    canvas.embed_png(png, 0, 0, tree_w, tree_h)
+
+    wanted = set(panel.rows)
+    rows = [(t.name, t.y) for t in geom.tips if t.name in wanted]
+    if rows:
+        panel.draw(canvas, tree_w + gap, width - pad, rows, canvas.style)
+    return Composite(canvas)

phylustrator-0.1.0/src/phylustrator/genomes/__init__.py

@@ -0,0 +1,23 @@
+"""The **genomes** domain — plot genomes, synteny and alignments. Same grammar as ``trees``:
+``phylustrator.genomes.plot(genome) + layer + …``
+
+    import phylustrator as ph
+    G = ph.zombi.read_genomes("run")                 # or ph.genomes.read_gff("genome.gff")
+    (ph.genomes.plot(G["n12"], layout="circular") + ph.genomes.genes(by="family")).save("ring.png")
+"""
+
+from __future__ import annotations
+
+from .figure import Figure, StackFigure, plot, stack
+from .genome import Chromosome, Gene, Genome
+from .io import read_gff
+from .layers import genes, highlight, position_axis, synteny
+from .matrix import Alignment, Matrix
+from .panels import alignment, heatmap, states
+
+__all__ = [
+    "Gene", "Chromosome", "Genome", "read_gff",
+    "plot", "stack", "Figure", "StackFigure",
+    "genes", "synteny", "highlight", "position_axis",
+    "Matrix", "Alignment", "heatmap", "alignment", "states",
+]