@pikaa-ai/pikaa 0.3.22 → 0.3.24

package/skills/esm/SKILL.md

@@ -1,334 +0,0 @@
----
-name: esm
-description: Use when working directly with the `esm` Python SDK, ESM3 or ESMC model IDs, Forge/Biohub inference clients, or ESMFold2 folding workflows.
-license: MIT license
-metadata:
-  version: "1.1"
-  skill-author: K-Dense Inc.
----
-
-# ESM: Evolutionary Scale Modeling
-
-## Overview
-
-ESM provides protein language models for understanding, generating, and designing proteins. Use this skill for current EvolutionaryScale/Biohub workflows: ESM3 for generative design, ESMC for representation learning and embeddings, hosted Forge/Biohub inference, and ESMFold2 all-atom structure prediction.
-
-## Core Capabilities
-
-### 1. Protein Sequence Generation with ESM3
-
-Generate novel protein sequences with desired properties using multimodal generative modeling.
-
-**When to use:**
-- Designing proteins with specific functional properties
-- Completing partial protein sequences
-- Generating variants of existing proteins
-- Creating proteins with desired structural characteristics
-
-**Basic usage:**
-
-```python
-from esm.models.esm3 import ESM3
-from esm.sdk.api import ESM3InferenceClient, ESMProtein, GenerationConfig
-
-# Load local open weights after accepting the license on Hugging Face.
-model: ESM3InferenceClient = ESM3.from_pretrained("esm3-open").to("cuda")
-
-# Create protein prompt
-protein = ESMProtein(sequence="MPRT___KEND")  # '_' represents masked positions
-
-# Generate completion
-protein = model.generate(protein, GenerationConfig(track="sequence", num_steps=8))
-print(protein.sequence)
-```
-
-**For remote/cloud usage via Forge API:**
-
-```python
-import os
-import esm
-from esm.sdk.api import ESMProtein, GenerationConfig
-
-# Same interface as local ESM3; token from ESM_API_KEY (see Authentication)
-model = esm.sdk.client("esm3-medium-2024-08", token=os.environ["ESM_API_KEY"])
-
-# Generate
-protein = model.generate(protein, GenerationConfig(track="sequence", num_steps=8))
-```
-
-See `references/esm3-api.md` for detailed ESM3 model specifications, advanced generation configurations, and multimodal prompting examples.
-
-### 2. Structure Prediction and Inverse Folding
-
-Use ESM3's structure track for structure prediction from sequence or inverse folding (sequence design from structure).
-
-**Structure prediction:**
-
-```python
-from esm.sdk.api import ESM3InferenceClient, ESMProtein, GenerationConfig
-
-# Predict structure from sequence
-protein = ESMProtein(sequence="MPRTKEINDAGLIVHSP...")
-protein_with_structure = model.generate(
-    protein,
-    GenerationConfig(track="structure", num_steps=protein.sequence.count("_"))
-)
-
-# Access predicted structure
-coordinates = protein_with_structure.coordinates  # 3D coordinates
-pdb_string = protein_with_structure.to_pdb()
-```
-
-**Inverse folding (sequence from structure):**
-
-```python
-# Design sequence for a target structure
-protein_with_structure = ESMProtein.from_pdb("target_structure.pdb")
-protein_with_structure.sequence = None  # Remove sequence
-
-# Generate sequence that folds to this structure
-designed_protein = model.generate(
-    protein_with_structure,
-    GenerationConfig(track="sequence", num_steps=50, temperature=0.7)
-)
-```
-
-### 3. Protein Embeddings with ESM C
-
-Generate high-quality embeddings for downstream tasks like function prediction, classification, or similarity analysis.
-
-**When to use:**
-- Extracting protein representations for machine learning
-- Computing sequence similarities
-- Feature extraction for protein classification
-- Transfer learning for protein-related tasks
-
-**Basic usage:**
-
-```python
-from esm.models.esmc import ESMC
-from esm.sdk.api import ESMProtein, LogitsConfig
-
-# Load ESM C model
-model = ESMC.from_pretrained("esmc_300m").to("cuda")
-
-# Get embeddings
-protein = ESMProtein(sequence="MPRTKEINDAGLIVHSP...")
-protein_tensor = model.encode(protein)
-logits_output = model.logits(
-    protein_tensor,
-    LogitsConfig(sequence=True, return_embeddings=True),
-)
-embeddings = logits_output.embeddings
-```
-
-**Batch processing:**
-
-```python
-# Encode multiple proteins
-proteins = [
-    ESMProtein(sequence="MPRTKEIND..."),
-    ESMProtein(sequence="AGLIVHSPQ..."),
-    ESMProtein(sequence="KTEFLNDGR...")
-]
-
-embeddings_list = [
-    model.logits(
-        model.encode(p),
-        LogitsConfig(sequence=True, return_embeddings=True),
-    ).embeddings
-    for p in proteins
-]
-```
-
-See `references/esm-c-api.md` for ESM C model details, efficiency comparisons, and advanced embedding strategies.
-
-### 4. Function Conditioning and Annotation
-
-Use ESM3's function track to generate proteins with specific functional annotations or predict function from sequence.
-
-**Function-conditioned generation:**
-
-```python
-from esm.sdk.api import ESMProtein, FunctionAnnotation, GenerationConfig
-
-# Create protein with desired function
-protein = ESMProtein(
-    sequence="_" * 200,  # Generate 200 residue protein
-    function_annotations=[
-        FunctionAnnotation(label="fluorescent_protein", start=50, end=150)
-    ]
-)
-
-# Generate sequence with specified function
-functional_protein = model.generate(
-    protein,
-    GenerationConfig(track="sequence", num_steps=200)
-)
-```
-
-### 5. Chain-of-Thought Generation
-
-Iteratively refine protein designs using ESM3's chain-of-thought generation approach.
-
-```python
-from esm.sdk.api import GenerationConfig
-
-# Multi-step refinement
-protein = ESMProtein(sequence="MPRT" + "_" * 100 + "KEND")
-
-# Step 1: Generate initial structure
-config = GenerationConfig(track="structure", num_steps=50)
-protein = model.generate(protein, config)
-
-# Step 2: Refine sequence based on structure
-config = GenerationConfig(track="sequence", num_steps=50, temperature=0.5)
-protein = model.generate(protein, config)
-
-# Step 3: Predict function
-config = GenerationConfig(track="function", num_steps=20)
-protein = model.generate(protein, config)
-```
-
-### 6. Batch Processing with Forge API
-
-Process multiple proteins efficiently using Forge's async methods.
-
-```python
-import os
-import asyncio
-import esm
-from esm.sdk.api import ESMProtein, GenerationConfig
-
-client = esm.sdk.client("esm3-medium-2024-08", token=os.environ["ESM_API_KEY"])
-
-# Async batch processing
-async def batch_generate(proteins_list):
-    tasks = [
-        client.async_generate(protein, GenerationConfig(track="sequence"))
-        for protein in proteins_list
-    ]
-    return await asyncio.gather(*tasks)
-
-# Execute
-proteins = [ESMProtein(sequence=f"MPRT{'_' * 50}KEND") for _ in range(10)]
-results = asyncio.run(batch_generate(proteins))
-```
-
-See `references/forge-api.md` for detailed Forge API documentation, authentication, rate limits, and batch processing patterns.
-
-## Model Selection Guide
-
-**ESM3 Models (Generative):**
-- `esm3-open` (1.4B) - Open weights, local usage after accepting the Hugging Face license
-- `esm3-medium-2024-08` (7B) - Best balance of quality and speed (Forge only)
-- `esm3-large-2024-03` (98B) - Highest quality, slower (Forge only)
-
-**ESM C Models (Embeddings):**
-- `esmc_300m` / `esmc-300m-2024-12` (30 layers) - Lightweight, fast inference (open weights, local)
-- `esmc_600m` / `esmc-600m-2024-12` (36 layers) - Balanced performance (open weights, local)
-- `esmc-6b-2024-12` (80 layers) - Maximum quality (Forge API; local 6B weights require Forge or SageMaker)
-
-Local `ESMC.from_pretrained()` examples use underscore aliases (`esmc_300m`, `esmc_600m`). Hosted API clients use dated model IDs such as `esmc-600m-2024-12`.
-
-**Selection criteria:**
-- **Local development/testing:** Use `esm3-open` or `esmc_300m`
-- **Production quality:** Use `esm3-medium-2024-08` via Forge
-- **Maximum accuracy:** Use `esm3-large-2024-03` or `esmc-6b-2024-12` via Forge
-- **High throughput:** Use Forge or Biohub APIs with explicit async concurrency limits
-- **Cost optimization:** Use smaller models, implement caching strategies
-
-## Installation
-
-Install from PyPI ([`esm` on PyPI](https://pypi.org/project/esm/) by EvolutionaryScale). Current PyPI release: **3.2.3** (Oct 14, 2025). Requires **Python >=3.12,<3.13**.
-
-**Basic installation:**
-
-```bash
-uv pip install "esm==3.2.3"
-```
-
-**With Flash Attention (recommended for faster inference on NVIDIA GPUs):**
-
-```bash
-uv pip install "esm==3.2.3"
-uv pip install flash-attn --no-build-isolation
-```
-
-The Forge client ships with the `esm` package - no extra install for ESM3 or ESMC Forge inference.
-
-## Authentication
-
-Forge API access requires an API key. Never hardcode tokens in scripts or commit them to version control.
-
-1. Check whether `ESM_API_KEY` is already set in the environment.
-2. If not, check a local `.env` for `ESM_API_KEY` only (do not load unrelated secrets).
-3. If still missing, create a key in the [Biohub developer console](https://biohub.ai/developer-console/api-keys) for Biohub APIs or [Forge](https://forge.evolutionaryscale.ai) for legacy Forge-hosted ESM3/ESMC access.
-
-```python
-import os
-
-token = os.environ["ESM_API_KEY"]  # raises KeyError if unset
-```
-
-`esm.sdk.client()` reads `ESM_API_KEY` automatically when `token` is omitted. Keep endpoint URLs fixed to trusted hosts such as `https://forge.evolutionaryscale.ai` or `https://biohub.ai`; do not take API hosts from untrusted user input.
-
-**Biohub platform:** EvolutionaryScale and Forge now surface current hosted models through [biohub.ai](https://biohub.ai). SDK class names may still reference "Forge". See `references/biohub-platform.md` for ESMFold2 and Biohub-specific setup.
-
-## Common Workflows
-
-For detailed examples and complete workflows, see `references/workflows.md` which includes:
-- Novel GFP design with chain-of-thought
-- Protein variant generation and screening
-- Structure-based sequence optimization
-- Function prediction pipelines
-- Embedding-based clustering and analysis
-
-## References
-
-This skill includes comprehensive reference documentation:
-
-- `references/esm3-api.md` - ESM3 model architecture, API reference, generation parameters, and multimodal prompting
-- `references/esm-c-api.md` - ESM C model details, embedding strategies, and performance optimization
-- `references/forge-api.md` - Forge platform documentation, authentication, batch processing, and deployment
-- `references/biohub-platform.md` - Biohub API migration, ESMFold2 structure prediction, and developer-console auth
-- `references/workflows.md` - Complete examples and common workflow patterns
-
-These references contain detailed API specifications, parameter descriptions, and advanced usage patterns. Load them as needed for specific tasks.
-
-## Best Practices
-
-**For generation tasks:**
-- Start with smaller models for prototyping (`esm3-open`)
-- Use temperature parameter to control diversity (0.0 = deterministic, 1.0 = diverse)
-- Implement iterative refinement with chain-of-thought for complex designs
-- Validate generated sequences with structure prediction or wet-lab experiments
-
-**For embedding tasks:**
-- Batch process sequences when possible for efficiency
-- Cache embeddings for repeated analyses
-- Normalize embeddings when computing similarities
-- Use appropriate model size based on downstream task requirements
-
-**For production deployment:**
-- Use Forge API for scalability and latest models
-- Implement error handling and retry logic for API calls
-- Monitor token usage and implement rate limiting
-- Consider AWS SageMaker deployment for dedicated infrastructure
-
-## Resources and Documentation
-
-- **GitHub Repository:** https://github.com/Biohub/esm (current ESMC/ESMFold2/Biohub docs; ESM3 docs remain linked from the repository)
-- **Forge Platform:** https://forge.evolutionaryscale.ai
-- **Biohub Platform:** https://biohub.ai
-- **Scientific Paper:** Hayes et al., Science (2025) - https://www.science.org/doi/10.1126/science.ads0018
-- **Blog Posts:**
-  - ESM3 Release: https://www.evolutionaryscale.ai/blog/esm3-release
-  - ESM C Launch: https://www.evolutionaryscale.ai/blog/esm-cambrian
-- **Community:** Slack community at https://bit.ly/3FKwcWd
-- **Model Weights:** Hugging Face EvolutionaryScale and Biohub organizations
-
-## Responsible Use
-
-ESM is designed for beneficial applications in protein engineering, drug discovery, and scientific research. Follow the Responsible Biodesign Framework (https://responsiblebiodesign.ai/) and Biohub Acceptable Use Policy (https://biohub.org/acceptable-use-policy/) when designing novel proteins. Consider biosafety and ethical implications of protein designs before experimental validation.
-

package/skills/etetoolkit/SKILL.md

@@ -1,327 +0,0 @@
----
-name: etetoolkit
-description: Analyze, manipulate, compare, annotate, and visualize phylogenetic or other hierarchical trees with ETE 4. Use for Newick/Nexus tree I/O, topology edits and pattern matching, Robinson-Foulds comparisons, gene-tree evolutionary events and reconciliation, NCBI/GTDB taxonomy, SmartView exploration, and publication rendering. Do not use it to infer trees from raw sequences; align sequences and infer a tree first.
-license: GPL-3.0-or-later
-allowed-tools: Read Write Edit Bash Python
-compatibility: Bundled scripts require Python 3.10+ and ete4 4.4.0 (upstream ete4 supports Python >=3.7). Taxonomy setup and SmartView exploration need network access; static SmartView PNG rendering needs ete4[render-sm], and Qt PDF/SVG rendering needs ete4[treeview].
-metadata:
-  version: "2.0"
-  skill-author: K-Dense Inc.
----
-
-# ETE Toolkit 4
-
-## Scope
-
-Use ETE 4 to work with an existing tree:
-
-- Read Newick/Nexus, then inspect, annotate, transform, root, prune, and write
-  Newick trees
-- Compare topologies and calculate phylogenetic distances
-- Find repeated subtree topologies with `TreePattern`
-- Analyze gene trees with `PhyloTree`
-- Query local NCBI or GTDB taxonomy databases
-- Explore large trees interactively with SmartView
-- Render PNG with SmartView or PNG/PDF/SVG with the optional Qt treeview
-
-ETE does not replace sequence alignment or phylogenetic inference software. For
-raw sequences, first use MAFFT or another aligner and IQ-TREE 2, FastTree, or
-another inference tool; then load the resulting tree into ETE.
-
-## Current Target
-
-This skill targets **ETE 4.4.0**, released September 3, 2025 and verified as the
-current PyPI release on July 23, 2026.
-
-Use `https://etetoolkit.github.io/ete/` for ETE 4 documentation. The
-`etetoolkit.org/docs/latest` pages are legacy ETE 3 documentation despite the
-URL name.
-
-Do not silently translate these examples back to ETE 3:
-
-- Package and import: `ete4`, not `ete3`
-- File input: pass an open file object; use strings for Newick text and do not
-  rely on path-string heuristics retained in ETE 4.4.0
-- Newick selection: `parser=`, not `format=`
-- Node metadata: `props`, `add_prop()`, and `add_props()`
-- Iteration: `leaves()`, `descendants()`, and related methods return iterators
-- Predicates: `node.is_leaf` and `node.is_root` are properties, not methods
-- Node lookup: `tree["name"]`, not `tree & "name"`
-
-For porting older code, load
-[`references/migration-ete3-to-ete4.md`](references/migration-ete3-to-ete4.md).
-
-## Installation
-
-Install the pinned base package:
-
-```bash
-uv pip install "ete4==4.4.0"
-```
-
-Add only the visualization extra required by the workflow:
-
-```bash
-# SmartView static PNG screenshots
-uv pip install "ete4[render-sm]==4.4.0"
-
-# Legacy Qt renderer for PNG, PDF, and SVG
-uv pip install "ete4[treeview]==4.4.0"
-```
-
-Confirm the active environment:
-
-```bash
-uv run --with "ete4==4.4.0" python -c "import ete4; print(ete4.__version__)"
-```
-
-No credentials are required. NCBI and GTDB workflows download public taxonomy
-data and can consume substantial disk space; see
-[`references/taxonomy.md`](references/taxonomy.md) before the first update.
-
-## Quick Start
-
-```python
-from pathlib import Path
-
-from ete4 import Tree
-
-# Use an open file object for files; reserve strings for Newick text.
-with Path("tree.nw").open(encoding="utf-8") as handle:
-    tree = Tree(handle, parser=1)  # parser 1: internal node names
-
-print(tree.to_str(props=["name", "dist"], compact=True))
-print("Leaves:", list(tree.leaf_names()))
-
-# Search and annotate.
-focal = tree["species1"]
-focal.add_props(host="human", status="focal")
-
-# Keep selected tips while preserving pairwise branch-length distances.
-tree.prune(
-    ["species1", "species2", "species3"],
-    preserve_branch_length=True,
-)
-
-# Root and serialize explicitly.
-tree.set_midpoint_outgroup()
-tree.write(
-    outfile="processed.nw",
-    parser=1,
-    props=["host", "status"],
-)
-```
-
-Choose the parser deliberately. A parser mismatch is the most common cause of
-`NewickError`, lost internal labels, or support values being read as names.
-See [`references/api_reference.md`](references/api_reference.md).
-
-## Core Workflows
-
-### Inspect and transform a tree
-
-```python
-from ete4 import Tree
-
-tree = Tree("((A:1,B:1)CladeAB:0.4,C:2)Root;", parser=1)
-
-for node in tree.traverse("preorder"):
-    label = node.name if node.name is not None else node.id
-    print(label, node.level, node.is_leaf, node.dist)
-
-tree["A"].add_prop("group", "case")
-tree["B"].add_prop("group", "control")
-
-mrca = tree.common_ancestor("A", "B")
-print(mrca.name)
-
-tree.write(
-    outfile="annotated.nhx",
-    parser=1,
-    props=["group"],
-    format_root_node=True,
-)
-```
-
-Node names need not be unique. `tree["A"]` returns the first match; use
-`list(tree.search_nodes(name="A"))` and validate the count when duplicates are
-possible.
-
-### Compare two topologies
-
-```python
-from ete4 import Tree
-
-tree_a = Tree("((A,B),(C,D));")
-tree_b = Tree("((A,C),(B,D));")
-
-(
-    rf,
-    max_rf,
-    common_leaves,
-    edges_a,
-    edges_b,
-    discarded_a,
-    discarded_b,
-) = tree_a.robinson_foulds(tree_b)
-
-normalized_rf = rf / max_rf if max_rf else 0.0
-print(rf, max_rf, normalized_rf, sorted(common_leaves))
-```
-
-RF comparison uses shared leaf labels and requires meaningful, preferably
-unique names. Decide explicitly whether rooted or unrooted comparison is
-scientifically appropriate.
-
-### Detect duplication and speciation events
-
-```python
-from ete4 import PhyloTree
-
-gene_tree = PhyloTree(
-    "((Hsa|g1,Ptr|g1),(Hsa|g2,Mmu|g1));",
-    sp_naming_function=lambda name: name.split("|", 1)[0],
-)
-
-for event in gene_tree.get_descendant_evol_events(sos_thr=0.0):
-    relationship = "speciation/orthology" if event.etype == "S" else "duplication/paralogy"
-    print(relationship, sorted(event.in_seqs), sorted(event.out_seqs))
-```
-
-Species-overlap calls are inferences from the supplied topology and naming
-function, not independent evidence of orthology. Pass the naming function
-explicitly, and use a rooted, fully bifurcating gene tree. For strict
-reconciliation, use a curated species tree and
-`gene_tree.reconcile(species_tree)`.
-
-### Query taxonomy
-
-```python
-from ete4 import NCBITaxa
-
-ncbi = NCBITaxa()
-names = ["Homo sapiens", "Pan troglodytes", "Mus musculus"]
-name_to_taxids = ncbi.get_name_translator(names)
-
-missing = [name for name in names if name not in name_to_taxids]
-if missing:
-    raise ValueError(f"Names not resolved by NCBI taxonomy: {missing}")
-
-taxids = [name_to_taxids[name][0] for name in names]
-taxonomy_tree = ncbi.get_topology(taxids)
-print(taxonomy_tree.to_str(props=["sci_name", "rank"]))
-```
-
-ETE 4 also provides `GTDBTaxa` for genome-centric bacterial and archaeal
-taxonomy. Do not mix NCBI numeric TaxIDs and GTDB string identifiers.
-
-### Visualize
-
-Interactive SmartView:
-
-```python
-from ete4 import Tree
-
-tree = Tree("((A:1,B:1)90:0.2,C:1);", parser="support")
-tree.explore()
-```
-
-Static SmartView screenshot:
-
-```python
-tree.render_sm("tree.png", w=1200, h=800)
-```
-
-`render_sm()` produces PNG screenshot data; use the Qt treeview renderer when
-the deliverable must be vector PDF or SVG. Load
-[`references/visualization.md`](references/visualization.md) for layouts,
-faces, remote exploration, and renderer selection.
-
-## Bundled Scripts
-
-Run from this skill directory. The commands below use a pinned, isolated ETE 4
-runtime through `uv run --with`.
-
-### Tree operations
-
-```bash
-uv run --with "ete4==4.4.0" python scripts/tree_operations.py \
-  stats tree.nw --parser 1
-uv run --with "ete4==4.4.0" python scripts/tree_operations.py \
-  ascii tree.nw --parser 1 --props name,dist
-uv run --with "ete4==4.4.0" python scripts/tree_operations.py \
-  convert tree.nw output.nw \
-  --input-parser 1 --output-parser 1
-uv run --with "ete4==4.4.0" python scripts/tree_operations.py \
-  reroot tree.nw rooted.nw \
-  --parser 1 --midpoint
-uv run --with "ete4==4.4.0" python scripts/tree_operations.py \
-  prune tree.nw pruned.nw \
-  --parser 1 --keep species1 species2 species3
-uv run --with "ete4==4.4.0" python scripts/tree_operations.py \
-  compare tree_a.nw tree_b.nw
-```
-
-Use `--keep-file taxa.txt` instead of `--keep ...` for one taxon per line.
-The script refuses ambiguous or missing requested names rather than silently
-producing a partial tree.
-
-### Visualization
-
-```bash
-# Interactive SmartView
-uv run --with "ete4==4.4.0" python scripts/quick_visualize.py \
-  tree.nw --parser 1
-
-# SmartView PNG (requires ete4[render-sm])
-uv run --with "ete4[render-sm]==4.4.0" python scripts/quick_visualize.py \
-  tree.nw tree.png \
-  --parser support --mode circular --show-support --color-by-support
-
-# Vector output via Qt treeview (requires ete4[treeview])
-uv run --with "ete4[treeview]==4.4.0" python scripts/quick_visualize.py \
-  tree.nw tree.svg \
-  --parser 1 --engine treeview --title "Species phylogeny"
-```
-
-## Quality and Interpretation Checks
-
-Before reporting a result:
-
-1. Confirm the parser preserves the intended internal names, support, and
-   branch lengths.
-2. Check for empty and duplicate leaf names before name-based lookup or RF
-   comparison.
-3. State whether the tree is treated as rooted or unrooted.
-4. Preserve branch lengths when pruning only if retained pairwise distances
-   should remain unchanged.
-5. Treat arbitrary polytomy resolution as a display/algorithmic convenience,
-   not evolutionary evidence.
-6. Record ETE version, parser, rooting method, pruning set, and taxonomy
-   database snapshot in reproducible analyses.
-7. Prefer iterators for large trees and `get_cached_content()` for repeated
-   descendant-content queries.
-
-## Reference Map
-
-Load only the reference needed for the task:
-
-- [`references/api_reference.md`](references/api_reference.md) — ETE 4 core
-  classes, parsers, properties, traversal, I/O, topology, and comparison
-- [`references/workflows.md`](references/workflows.md) — complete analysis
-  patterns, validation, reconciliation, batching, and large-tree work
-- [`references/visualization.md`](references/visualization.md) — SmartView,
-  layouts/faces, PNG screenshots, and Qt vector rendering
-- [`references/taxonomy.md`](references/taxonomy.md) — NCBI and GTDB setup,
-  translation, topology, annotation, and reproducibility
-- [`references/migration-ete3-to-ete4.md`](references/migration-ete3-to-ete4.md)
-  — breaking API changes and porting checklist
-
-## Authoritative Upstream Sources
-
-- Documentation: https://etetoolkit.github.io/ete/
-- ETE 3 to ETE 4 migration: https://etetoolkit.github.io/ete/3to4.html
-- Releases: https://github.com/etetoolkit/ete/releases
-- PyPI: https://pypi.org/project/ete4/
-- Source: https://github.com/etetoolkit/ete
-- Visualization gallery: https://github.com/etetoolkit/ete-gallery