react-bio-viz 0.1.0__tar.gz

react_bio_viz-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+# Built by `pnpm --filter @react-bio-viz/python-widgets build` (and by the hatchling build hook
+# when packaging). Ships inside the wheel/sdist; not tracked in git.
+src/react_bio_viz/static/widget.js
+src/react_bio_viz/static/widget.css
+
+node_modules/
+.venv/
+dist/
+*.egg-info/
+__pycache__/
+.pytest_cache/

react_bio_viz-0.1.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.5
+Name: react-bio-viz
+Version: 0.1.0
+Summary: Jupyter widgets for biological data visualization: multiple sequence alignments, phylogenetic trees, gene models, genome browser tracks, and BLAST hit distributions
+Project-URL: Homepage, https://github.com/holmrenser/react-bio-viz
+Project-URL: Repository, https://github.com/holmrenser/react-bio-viz
+License: MIT
+Keywords: bioinformatics,jupyter,msa,phylogenetics,visualization,widget
+Classifier: Framework :: Jupyter
+Classifier: Framework :: Jupyter :: JupyterLab :: 3
+Classifier: Framework :: Jupyter :: JupyterLab :: 4
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.9
+Requires-Dist: anywidget>=0.9
+Provides-Extra: dev
+Requires-Dist: anywidget[dev]>=0.9; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# react-bio-viz
+
+Jupyter widgets for biological data visualization: multiple sequence alignments, phylogenetic
+trees, distance matrices, gene models, genome browser tracks, and BLAST hit distributions.
+
+These are [anywidget](https://anywidget.dev) bindings around the `react-bio-viz` React components,
+so the same visualizations run in a notebook and in a web app.
+
+## Install
+
+```bash
+pip install react-bio-viz
+```
+
+## Use
+
+```python
+from react_bio_viz import MSA
+
+widget = MSA(msa=[
+    {"header": "seq1", "sequence": "MKTAYIAKQRQISFVK"},
+    {"header": "seq2", "sequence": "MKTAYIAKQRQISFVR"},
+])
+widget
+```
+
+Every piece of interactive state is an ordinary synced traitlet, so the kernel can both **drive**
+and **observe** it — no bespoke callback API, just traitlets' own idiom:
+
+```python
+# Observe: fires whenever the user pans, zooms, or selects in the browser.
+widget.observe(lambda change: print(change["new"]), names="viewport")
+
+# Drive: writing the trait moves the view.
+widget.viewport = {**widget.viewport, "x0": 0, "x1": 50}
+```
+
+### Widgets
+
+| Class | Data prop | Interactive traits |
+| --- | --- | --- |
+| `MSA` | `msa` | `viewport`, `selection`, `row_order`, `panel_sizes` |
+| `PhyloTree` | `tree` | `viewport`, `selection`; `leaf_order` (read-only) |
+| `DistanceMatrix` | `labels`, `matrix` | `viewport`, `row_order`, `panel_sizes` |
+| `GeneModel` | `gene` | `viewport` |
+| `GenomeBrowser` | `tracks`, `reference_length` | `viewport` |
+| `BlastHitDistribution` | `hits`, `query_length` | `viewport`, `selection`, `metric` |
+
+`viewport` is a plain dict — `{"x0", "x1", "y0", "y1", "xMin", "xMax", "yMin", "yMax"}` — seeded on
+construction to show the whole dataset, so it is readable and observable before any interaction.
+
+`selection` is `{"rows", "columns"}` for `MSA`, `{"rerootedAt", "rerootPosition", "collapsed",
+"order"}` for `PhyloTree` and `{"selectedHitIds"}` for `BlastHitDistribution`. `row_order` has the
+same shape on `MSA` and `DistanceMatrix`, so one can follow the other with a plain `observe`.
+
+User actions that are events rather than state arrive through callbacks. The widgets never edit
+their data themselves — apply the change and assign the new data back:
+
+```python
+msa = MSA(msa=records)
+msa.on_rename_row(lambda row_id, name: ...)
+msa.on_remove_rows(lambda row_ids: ...)
+msa.on_remove_columns(lambda columns: ...)
+
+tree = PhyloTree(tree=tree_dict, interactive=True)
+tree.on_node_click(lambda node: print(node["id"], node["leafNames"]))
+tree.on_branch_click(lambda node: ...)
+```
+
+```python
+from react_bio_viz import BlastHitDistribution
+
+hits = BlastHitDistribution(hits=blast_rows, query_length=2000)
+hits.observe(lambda c: print("selected:", c["new"]["selectedHitIds"]), names="selection")
+hits
+```
+
+### Naming
+
+Traits are `snake_case` (idiomatic Python) and map to the React components' `camelCase` props;
+values that are themselves data — viewport keys, `selection` keys, `options` keys — keep their
+`camelCase` spelling, since they cross the wire as JSON and are documented by the JavaScript API.
+
+## How it works
+
+An anywidget model is structurally already a `StoreController`, the external-store seam the React
+components use for controlled state (`model.get` / `model.set` + `save_changes` / `on("change:…")`
+↔ `getValue` / `setValue` / `subscribe`). So the Jupyter integration is one adapter,
+`createAnywidgetStoreController`, and **no component contains any Jupyter-specific code** — a
+notebook is just another external-store consumer, the same kind of thing as a web app's Zustand
+store.
+
+All six widgets share a single bundled ES module, dispatching on an internal `_component` trait,
+so React ships once in the wheel rather than once per widget.
+
+`PhyloTree`'s layout trait is `tree_layout` (ipywidgets reserves `layout` for a widget's CSS layout);
+`PhyloTree(layout="radial")` is accepted as a shorthand.
+
+## Example notebook
+
+[`examples/tour.ipynb`](examples/tour.ipynb) loads an alignment, computes p-distances and a
+neighbour-joining tree in plain Python, and links all three views. Documentation:
+<https://holmrenser.github.io/react-bio-viz/python/>.
+
+## Development
+
+```bash
+pnpm --filter @react-bio-viz/python-widgets build   # bundle the widget JavaScript
+uv pip install -e ".[dev]"
+pytest
+```
+
+The wheel needs `src/react_bio_viz/static/widget.js`; the hatchling build hook builds it with
+Node if it is missing, and skips when it is already there (so installing from an sdist or wheel
+needs no Node toolchain).
+
+## License
+
+MIT

react_bio_viz-0.1.0/README.md

@@ -0,0 +1,119 @@
+# react-bio-viz
+
+Jupyter widgets for biological data visualization: multiple sequence alignments, phylogenetic
+trees, distance matrices, gene models, genome browser tracks, and BLAST hit distributions.
+
+These are [anywidget](https://anywidget.dev) bindings around the `react-bio-viz` React components,
+so the same visualizations run in a notebook and in a web app.
+
+## Install
+
+```bash
+pip install react-bio-viz
+```
+
+## Use
+
+```python
+from react_bio_viz import MSA
+
+widget = MSA(msa=[
+    {"header": "seq1", "sequence": "MKTAYIAKQRQISFVK"},
+    {"header": "seq2", "sequence": "MKTAYIAKQRQISFVR"},
+])
+widget
+```
+
+Every piece of interactive state is an ordinary synced traitlet, so the kernel can both **drive**
+and **observe** it — no bespoke callback API, just traitlets' own idiom:
+
+```python
+# Observe: fires whenever the user pans, zooms, or selects in the browser.
+widget.observe(lambda change: print(change["new"]), names="viewport")
+
+# Drive: writing the trait moves the view.
+widget.viewport = {**widget.viewport, "x0": 0, "x1": 50}
+```
+
+### Widgets
+
+| Class | Data prop | Interactive traits |
+| --- | --- | --- |
+| `MSA` | `msa` | `viewport`, `selection`, `row_order`, `panel_sizes` |
+| `PhyloTree` | `tree` | `viewport`, `selection`; `leaf_order` (read-only) |
+| `DistanceMatrix` | `labels`, `matrix` | `viewport`, `row_order`, `panel_sizes` |
+| `GeneModel` | `gene` | `viewport` |
+| `GenomeBrowser` | `tracks`, `reference_length` | `viewport` |
+| `BlastHitDistribution` | `hits`, `query_length` | `viewport`, `selection`, `metric` |
+
+`viewport` is a plain dict — `{"x0", "x1", "y0", "y1", "xMin", "xMax", "yMin", "yMax"}` — seeded on
+construction to show the whole dataset, so it is readable and observable before any interaction.
+
+`selection` is `{"rows", "columns"}` for `MSA`, `{"rerootedAt", "rerootPosition", "collapsed",
+"order"}` for `PhyloTree` and `{"selectedHitIds"}` for `BlastHitDistribution`. `row_order` has the
+same shape on `MSA` and `DistanceMatrix`, so one can follow the other with a plain `observe`.
+
+User actions that are events rather than state arrive through callbacks. The widgets never edit
+their data themselves — apply the change and assign the new data back:
+
+```python
+msa = MSA(msa=records)
+msa.on_rename_row(lambda row_id, name: ...)
+msa.on_remove_rows(lambda row_ids: ...)
+msa.on_remove_columns(lambda columns: ...)
+
+tree = PhyloTree(tree=tree_dict, interactive=True)
+tree.on_node_click(lambda node: print(node["id"], node["leafNames"]))
+tree.on_branch_click(lambda node: ...)
+```
+
+```python
+from react_bio_viz import BlastHitDistribution
+
+hits = BlastHitDistribution(hits=blast_rows, query_length=2000)
+hits.observe(lambda c: print("selected:", c["new"]["selectedHitIds"]), names="selection")
+hits
+```
+
+### Naming
+
+Traits are `snake_case` (idiomatic Python) and map to the React components' `camelCase` props;
+values that are themselves data — viewport keys, `selection` keys, `options` keys — keep their
+`camelCase` spelling, since they cross the wire as JSON and are documented by the JavaScript API.
+
+## How it works
+
+An anywidget model is structurally already a `StoreController`, the external-store seam the React
+components use for controlled state (`model.get` / `model.set` + `save_changes` / `on("change:…")`
+↔ `getValue` / `setValue` / `subscribe`). So the Jupyter integration is one adapter,
+`createAnywidgetStoreController`, and **no component contains any Jupyter-specific code** — a
+notebook is just another external-store consumer, the same kind of thing as a web app's Zustand
+store.
+
+All six widgets share a single bundled ES module, dispatching on an internal `_component` trait,
+so React ships once in the wheel rather than once per widget.
+
+`PhyloTree`'s layout trait is `tree_layout` (ipywidgets reserves `layout` for a widget's CSS layout);
+`PhyloTree(layout="radial")` is accepted as a shorthand.
+
+## Example notebook
+
+[`examples/tour.ipynb`](examples/tour.ipynb) loads an alignment, computes p-distances and a
+neighbour-joining tree in plain Python, and links all three views. Documentation:
+<https://holmrenser.github.io/react-bio-viz/python/>.
+
+## Development
+
+```bash
+pnpm --filter @react-bio-viz/python-widgets build   # bundle the widget JavaScript
+uv pip install -e ".[dev]"
+pytest
+```
+
+The wheel needs `src/react_bio_viz/static/widget.js`; the hatchling build hook builds it with
+Node if it is missing, and skips when it is already there (so installing from an sdist or wheel
+needs no Node toolchain).
+
+## License
+
+MIT

react_bio_viz-0.1.0/build.mjs

@@ -0,0 +1,35 @@
+import { build } from "esbuild";
+import { mkdir } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const outdir = resolve(here, "src/react_bio_viz/static");
+
+await mkdir(outdir, { recursive: true });
+
+/**
+ * Unlike the npm packages — which leave React external for the host app to provide — the widget
+ * bundle has to be self-contained: anywidget loads `_esm` as a standalone ES module in the
+ * notebook's page, with no bundler and no import map to resolve bare specifiers against.
+ *
+ * One bundle serves all five widgets, dispatching on the `_component` trait, so React ships once
+ * in the wheel instead of five times.
+ */
+await build({
+  entryPoints: [resolve(here, "js/widget.tsx")],
+  outfile: resolve(outdir, "widget.js"),
+  bundle: true,
+  format: "esm",
+  target: "es2020",
+  minify: true,
+  sourcemap: false,
+  jsx: "automatic",
+  // React libraries branch on this; without it esbuild keeps the dev-only paths (and the
+  // `process` reference they sit behind, which does not exist in a browser).
+  define: { "process.env.NODE_ENV": '"production"' },
+  loader: { ".css": "css" },
+  logLevel: "info",
+});
+
+console.log(`built ${outdir}/widget.js (+ widget.css)`);

react_bio_viz-0.1.0/hatch_build.py

@@ -0,0 +1,46 @@
+"""Bundles the widget JavaScript before hatchling packages the wheel or sdist.
+
+anywidget loads ``_esm`` as a standalone ES module in the notebook page, so the bundle has to be
+built and shipped inside the distribution — there is no bundler on the other side. This hook runs
+``node build.mjs`` when the artifact is missing, and stays out of the way when it is already
+there (an sdist install, or a checkout where ``pnpm --filter @react-bio-viz/python-widgets build``
+has run), so packaging never hard-requires a Node toolchain.
+"""
+
+from __future__ import annotations
+
+import pathlib
+import shutil
+import subprocess
+import sys
+from typing import Any
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+_ARTIFACTS = ("widget.js", "widget.css")
+
+
+class WidgetBuildHook(BuildHookInterface):
+    PLUGIN_NAME = "custom"
+
+    def initialize(self, version: str, build_data: dict[str, Any]) -> None:
+        root = pathlib.Path(self.root)
+        static = root / "src" / "react_bio_viz" / "static"
+
+        if all((static / name).is_file() for name in _ARTIFACTS):
+            return
+
+        node = shutil.which("node")
+        if node is None:
+            raise RuntimeError(
+                "The widget bundle is missing and Node.js was not found on PATH.\n"
+                "Build it first with `pnpm --filter @react-bio-viz/python-widgets build`, "
+                "or install from an sdist/wheel, which ships it prebuilt."
+            )
+
+        print("react-bio-viz: bundling widget JavaScript...", file=sys.stderr)
+        subprocess.run([node, "build.mjs"], cwd=root, check=True)
+
+        missing = [name for name in _ARTIFACTS if not (static / name).is_file()]
+        if missing:
+            raise RuntimeError(f"widget bundle did not produce: {', '.join(missing)}")

react_bio_viz-0.1.0/js/_storeAdapter.ts

@@ -0,0 +1,49 @@
+import type { StoreController } from "@react-bio-viz/core";
+
+/** The part of anywidget's `AnyModel` the bridge uses — structural, so it needs no anywidget types. */
+export interface AnyModel {
+  get(key: string): unknown;
+  set(key: string, value: unknown): void;
+  save_changes(): void;
+  on(event: string, callback: () => void): void;
+  off(event: string, callback: () => void): void;
+  /** Sends a custom message to the kernel (received by `widget.on_msg` in Python). */
+  send(content: Record<string, unknown>): void;
+}
+
+/**
+ * One synced trait as a {@link StoreController} — the seam a JavaScript app fills with a Zustand
+ * store, so no component has Jupyter-specific code. A trait written from Python re-renders the
+ * component; an interaction writes the trait back, firing `widget.observe` in the kernel.
+ *
+ * @param model - The anywidget model passed to `render({ model, el })`.
+ * @param key - The synced trait name to bind, e.g. `"viewport"` or `"selection"`.
+ */
+export function createAnywidgetStoreController<T>(model: AnyModel, key: string): StoreController<T> {
+  // The last non-null value, cached: `useSyncExternalStore` needs a stable snapshot between
+  // notifications, and a `null` one (before Python seeds the trait) would reach the component.
+  let snapshot = model.get(key) as T;
+
+  return {
+    getValue: () => {
+      const current = model.get(key) as T | null | undefined;
+      if (current !== null && current !== undefined) snapshot = current;
+      return snapshot;
+    },
+    setValue: (next) => {
+      const value = typeof next === "function" ? (next as (prev: T) => T)(snapshot) : next;
+      snapshot = value;
+      model.set(key, value);
+      model.save_changes();
+    },
+    subscribe: (listener) => {
+      const handler = () => {
+        const current = model.get(key) as T | null | undefined;
+        if (current !== null && current !== undefined) snapshot = current;
+        listener(snapshot);
+      };
+      model.on(`change:${key}`, handler);
+      return () => model.off(`change:${key}`, handler);
+    },
+  };
+}

react_bio_viz-0.1.0/js/widget.tsx

@@ -0,0 +1,163 @@
+import { createElement, type ComponentType, type ReactElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import {
+  BlastHitDistribution,
+  DistanceMatrix,
+  GeneModel,
+  GenomeBrowser,
+  MultipleSequenceAlignment,
+  PhyloTree,
+  type TreeNodeInfo,
+} from "react-bio-viz";
+import "react-bio-viz/style.css";
+
+import { createAnywidgetStoreController, type AnyModel } from "./_storeAdapter";
+
+/** How one Python widget class maps onto a React component. */
+interface WidgetSpec {
+  render: (props: Record<string, unknown>) => ReactElement;
+  /**
+   * Data and display traits, bound to the camelCased prop of the same name — or, as a
+   * `[trait, prop]` pair, to another prop (a trait can't take a name ipywidgets uses, like `layout`).
+   */
+  props: (string | [string, string])[];
+  /** Interactive state: each trait binds, two-way, to the component's camelCased `<trait>Store` prop. */
+  stores: string[];
+  /** Callback props, each built from the model: a custom message to the kernel, or a trait write. */
+  events?: Record<string, (model: AnyModel) => (...args: never[]) => void>;
+}
+
+/** Node/branch click info without the screen coordinates, which mean nothing to the kernel. */
+function nodePayload({ clientX: _x, clientY: _y, ...info }: TreeNodeInfo) {
+  return info;
+}
+
+/**
+ * Renders a component from props assembled out of traits, which TypeScript can't check: the Python
+ * class guarantees the required ones (and its tests assert the trait set).
+ */
+function bridge<P>(Component: ComponentType<P>): (props: Record<string, unknown>) => ReactElement {
+  const Dynamic = Component as unknown as ComponentType<Record<string, unknown>>;
+  return (props) => createElement(Dynamic, props);
+}
+
+/** snake_case trait → camelCase prop. */
+function toPropName(trait: string): string {
+  return trait.replace(/_([a-z])/g, (_match, char: string) => char.toUpperCase());
+}
+
+/** Store props are named for their state (`viewportStore`), so a trait binds to its prop by name alone. */
+const SPECS: Record<string, WidgetSpec> = {
+  msa: {
+    render: bridge(MultipleSequenceAlignment),
+    props: ["msa", "width", "height", "options"],
+    stores: ["viewport", "selection", "row_order", "panel_sizes"],
+    events: {
+      onRenameRow: (model) => (rowId: string, name: string) => model.send({ event: "rename_row", row_id: rowId, name }),
+      onRemoveRows: (model) => (rowIds: string[]) => model.send({ event: "remove_rows", row_ids: rowIds }),
+      onRemoveColumns: (model) => (columns: number[]) => model.send({ event: "remove_columns", columns }),
+    },
+  },
+  phylotree: {
+    render: bridge(PhyloTree),
+    props: [
+      "tree",
+      "width",
+      "height",
+      ["tree_layout", "layout"],
+      "show_support_values",
+      "support_threshold",
+      "shade_branch_by_support",
+      "font_size",
+      "align_tips",
+      "interactive",
+      "drag_enabled",
+      "search_query",
+      "search_use_regex",
+      "show_scale_bar",
+      "show_branch_lengths",
+      "branch_width",
+      "node_radius",
+      "label_font_size",
+      "leaf_spacing",
+      "leaf_marker_color",
+      "node_styles",
+      "branch_styles",
+      "active_node_id",
+    ],
+    stores: ["viewport", "selection"],
+    events: {
+      onNodeClick: (model) => (info: TreeNodeInfo) => model.send({ event: "node_click", node: nodePayload(info) }),
+      onBranchClick: (model) => (info: TreeNodeInfo) => model.send({ event: "branch_click", node: nodePayload(info) }),
+      onLeafOrderChange: (model) => (leafNames: string[]) => {
+        model.set("leaf_order", leafNames);
+        model.save_changes();
+      },
+    },
+  },
+  distancematrix: {
+    render: bridge(DistanceMatrix),
+    props: ["labels", "matrix", "label_names", "width", "height", "options"],
+    stores: ["viewport", "row_order", "panel_sizes"],
+  },
+  genemodel: {
+    render: bridge(GeneModel),
+    props: ["gene", "width", "color_seed", "show_scale"],
+    stores: ["viewport"],
+  },
+  genomebrowser: {
+    render: bridge(GenomeBrowser),
+    props: ["tracks", "reference_length", "reference_name", "width", "show_scale"],
+    stores: ["viewport"],
+  },
+  blasthitdistribution: {
+    render: bridge(BlastHitDistribution),
+    props: ["hits", "query_length", "query_name", "width", "show_scale"],
+    stores: ["viewport", "selection", "metric"],
+  },
+};
+
+function buildProps(model: AnyModel, spec: WidgetSpec): Record<string, unknown> {
+  const props: Record<string, unknown> = {};
+
+  for (const entry of spec.props) {
+    const [trait, prop] = typeof entry === "string" ? [entry, toPropName(entry)] : entry;
+    const value = model.get(trait);
+    // `None` means "not set": leave the prop off, so the component's default applies.
+    if (value !== null && value !== undefined) props[prop] = value;
+  }
+
+  for (const trait of spec.stores) {
+    // Python seeds these; an unset one leaves the state uncontrolled rather than null.
+    if (model.get(trait) === null || model.get(trait) === undefined) continue;
+    props[`${toPropName(trait)}Store`] = createAnywidgetStoreController(model, trait);
+  }
+
+  for (const [prop, handler] of Object.entries(spec.events ?? {})) props[prop] = handler(model);
+
+  return props;
+}
+
+function render({ model, el }: { model: AnyModel; el: HTMLElement }) {
+  const name = String(model.get("_component"));
+  const spec = SPECS[name];
+  if (!spec) {
+    el.textContent = `react-bio-viz: unknown component "${name}"`;
+    return;
+  }
+
+  const root: Root = createRoot(el);
+  const draw = () => root.render(spec.render(buildProps(model, spec)));
+  draw();
+
+  // Store traits re-render through their store; only the plain traits need a redraw from here.
+  const watched = spec.props.map((entry) => `change:${typeof entry === "string" ? entry : entry[0]}`);
+  for (const event of watched) model.on(event, draw);
+
+  return () => {
+    for (const event of watched) model.off(event, draw);
+    root.unmount();
+  };
+}
+
+export default { render };

react_bio_viz-0.1.0/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@react-bio-viz/python-widgets",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "esbuild bundle of the react-bio-viz components for the anywidget/Jupyter package (not published to npm; the artifact ships inside the PyPI wheel)",
+  "scripts": {
+    "build": "node build.mjs",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint": "eslint . --max-warnings 0"
+  },
+  "dependencies": {
+    "@react-bio-viz/core": "workspace:*",
+    "react-bio-viz": "workspace:*",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "esbuild": "^0.21.5",
+    "typescript": "^5.6.3"
+  }
+}

react_bio_viz-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "react-bio-viz"
+version = "0.1.0"
+description = "Jupyter widgets for biological data visualization: multiple sequence alignments, phylogenetic trees, gene models, genome browser tracks, and BLAST hit distributions"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+keywords = ["jupyter", "widget", "bioinformatics", "visualization", "msa", "phylogenetics"]
+classifiers = [
+    "Framework :: Jupyter",
+    "Framework :: Jupyter :: JupyterLab :: 3",
+    "Framework :: Jupyter :: JupyterLab :: 4",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+]
+dependencies = ["anywidget>=0.9"]
+
+[project.urls]
+Homepage = "https://github.com/holmrenser/react-bio-viz"
+Repository = "https://github.com/holmrenser/react-bio-viz"
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "anywidget[dev]>=0.9"]
+
+[tool.hatch.build]
+# The bundle is gitignored (it is generated), but it has to travel in both the wheel and the sdist:
+# building a wheel from an sdist has no `node_modules` to rebuild it from, and requiring the npm
+# workspace to install from source would make `pip install react-bio-viz` need a Node toolchain.
+artifacts = [
+    "src/react_bio_viz/static/widget.js",
+    "src/react_bio_viz/static/widget.css",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/react_bio_viz"]
+
+[tool.hatch.build.targets.sdist]
+# The JS sources travel too, so the bundle can be rebuilt/audited from the sdist alone.
+include = ["src", "js", "build.mjs", "hatch_build.py", "package.json", "README.md", "pyproject.toml"]
+# `include` still descends into the workspace symlinks pnpm leaves in `node_modules`.
+exclude = ["node_modules", ".venv", "dist"]
+
+# Bundles the widget JavaScript before packaging. Skipped when `static/widget.js` is already
+# present, so building from an sdist (or from a checkout where `pnpm build` has run) needs no
+# Node toolchain.
+[tool.hatch.build.hooks.custom]
+path = "hatch_build.py"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]