ipygraph 0.1.2__tar.gz → 1.14.1__tar.gz

{ipygraph-0.1.2 → ipygraph-1.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipygraph
-Version: 0.1.2
+Version: 1.14.1
 Summary: Turn your Jupyter notebook into a branching graph of experiments — a JupyterLab extension with a plan-first AI copilot, branch isolation, and fork-join parallel execution.
 Project-URL: Homepage, https://github.com/jupyterlab/jupyterlab-ipygb
 Project-URL: Bug Tracker, https://github.com/jupyterlab/jupyterlab-ipygb/issues
@@ -221,18 +221,21 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.10
 Requires-Dist: dill
 Requires-Dist: jupyter-server<3,>=2.0.0
+Requires-Dist: jupyterlab<5,>=4.0.0
 Description-Content-Type: text/markdown
 
-<h1 align="center">ipyGraph</h1>
+<p align="center">
+  <img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/logo-banner.png" alt="ipyGraph — Notebooks that branch" width="620">
+</p>
 
 <p align="center"><b>Turn your Jupyter notebook into a branching graph of experiments.</b></p>
 
 <p align="center">
-  <img src="docs/images/plan-view-detail.png" alt="ipyGraph plan view — a chess evaluation model built as a branching graph of self-describing steps" width="850">
+  <img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/plan-view-detail.png" alt="ipyGraph plan view — a chess evaluation model built as a branching graph of self-describing steps" width="820">
 </p>
 
 [![Build](https://github.com/jupyterlab/jupyterlab-ipygb/workflows/Build/badge.svg)](https://github.com/jupyterlab/jupyterlab-ipygb/actions/workflows/build.yml)
-&nbsp;JupyterLab 4 extension&nbsp;·&nbsp;`.ipygb` format&nbsp;·&nbsp;source-available
+&nbsp;JupyterLab 4 · `.ipygb` file format · runs at `/graph` · source-available
 
 ---
 
@@ -244,92 +247,105 @@ Notebooks are linear. **Experimentation isn't.**
 
 ## What ipyGraph is
 
-**ipyGraph** (a.k.a. *Graphbook*, file extension `.ipygb`) is a JupyterLab 4 extension that turns a notebook into a **branching DAG of cells**. Every experiment is a *branch* on a living graph instead of a copy-pasted block you'll never find again. A shared data-prep step forks into competing models; each branch keeps its own state; you compare tips and keep the winner.
+**ipyGraph** (a.k.a. *Graphbook*) is a JupyterLab 4 extension that turns a notebook into a **branching DAG of cells**. Every experiment is a *branch* on a living graph instead of a copy-pasted block you'll never find again. A shared data-prep step forks into competing models; each branch keeps its own state; you compare tips and keep the winner.
 
 It ships with a **plan-first AI copilot** that designs the experiment graph, writes the code, runs it, and iterates — and an execution engine where **one branch can never silently contaminate another**.
 
-The cells are real, runnable Jupyter cells — so outputs, plots, and the kernel all work exactly as you expect. When you're done, export any path as a plain `.ipynb`.
+You launch it with its own command and it opens at `/graph`:
+
+```bash
+pip install ipygraph
+jupytergraph          # opens JupyterLab at http://localhost:8888/graph
+```
+
+## The `.ipygb` file format
+
+ipyGraph adds a new document type: **`.ipygb`** (a "Graphbook"). It's a **superset of the Jupyter notebook format** — the same `nbformat` JSON with cells, outputs, and metadata — with a little extra per-cell `ipygb` metadata that records the graph:
+
+```jsonc
+"metadata": {
+  "ipygb": {
+    "parent_id": "root-1",        // which cell's outputs this one builds on
+    "branch_name": "encode-nn",   // the branch this cell starts (optional)
+    "parent_ids": ["a", "b"],     // 2+ parents = a merge cell
+    "description": "…",           // shown in Plan view
+    "inputs": { … }               // explicit variables a merge consumes
+  }
+}
+```
+
+Because it's a superset, the kernel, outputs, and rendering are ordinary Jupyter — nothing proprietary about how your code runs. And you can always **export any root→tip path back to a plain `.ipynb`** to share or hand off.
 
 ---
 
 ## See it
 
-The screenshots below are a real ipyGraph project: *predicting a chess engine's position evaluation from the board.* A shared prep step splits into two feature representations (tabular vs. board-planes), which feed different model families.
+The screenshots below are a real ipyGraph project — *predicting a chess engine's position evaluation from the board.* A shared prep step splits into two feature representations (tabular vs. board-planes), which feed different model families.
 
 **Plan view — the whole experiment reads like a flowchart, and every step documents itself:**
 
-<p align="center"><img src="docs/images/graph-plan-view.png" alt="Plan view: the full experiment graph" width="850"></p>
+<p align="center"><img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/graph-plan-view.png" alt="Plan view: the full experiment graph" width="820"></p>
 
 **Code view — those same nodes are real, runnable Jupyter cells with live outputs:**
 
-<p align="center"><img src="docs/images/graph-code-view.png" alt="Code view: the same graph as runnable cells" width="850"></p>
+<p align="center"><img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/graph-code-view.png" alt="Code view: the same graph as runnable cells" width="820"></p>
 
 **The AI copilot builds and iterates on the graph beside you (Autopilot is on by default):**
 
-<p align="center"><img src="docs/images/graph-with-assistant.png" alt="ipyGraph assistant panel" width="850"></p>
+<p align="center"><img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/graph-with-assistant.png" alt="ipyGraph assistant panel with a live conversation" width="820"></p>
 
 ---
 
-## Features
-
-### 🕸️ The graph is the interface
-- **Graph View is the default view.** Cells are laid out as a 2D flow — column = branch, row = depth — with parents centered over their children.
-- **Two views of one graph.** Flip between **Plan view** (titles + prose descriptions — read the whole experiment at a glance) and **Code view** (the real editors and outputs). The agent can switch views for you to show you what matters.
-- **Branch anywhere.** Fork a new branch from any cell with one click; extend a tip with `+ Cell`.
-- **Edit in place.** Type directly into cells on the graph, rename branches, and click-to-edit descriptions — no round-trip to a separate editor.
-- **Arrow-key navigation** and a **👁 Watch agent** button that pans the graph to whatever cell is being worked on, live.
-
-### 🤖 Plan-first AI copilot
-- **Describe a goal, get a plan on the graph.** The agent drafts the experiment as plan cells first — you approve, then it builds. It thinks in *dataflow*: shared prep on the trunk, a separate encoder per model family, models under their encoder.
-- **Multi-agent under the hood.** An architect-vs-critic design debate picks the model shortlist; parallel coder sub-agents fill in the branches concurrently.
-- **Finds data for you.** A full-screen dataset picker searches Kaggle and profiles candidates so you can choose the right one.
-- **Uses your Claude subscription** via the Claude Agent SDK (no API key needed), or bring an API key for Anthropic / OpenAI / Gemini.
-- **Minimal questions, fast turns** — it infers sensible defaults, asks only when a choice genuinely matters, and shows a live progress spinner while it works.
-
-### 🔒 Reproducible, isolated execution
-- **A cell's variables come only from its own path.** One branch can never be polluted by code you ran on another branch.
-- **▶ Run** a single cell, or **⇥ Run to here** to rebuild a path from the start on a clean, isolated kernel.
-- **Fork-point kernel snapshots.** State is saved at each branch point (fast, on-disk), so a sibling branch **resumes from a saved copy instead of replaying the whole path** — and the copy rolls forward as you iterate down a branch.
-- **True fork-join parallelism.** *"Run Parallel"* on a 1-prep → 3-model graph runs the prep **once** and trains the three models **concurrently** on separate kernels.
-- **Staleness badges.** A cell warns you — *"changed after last run"* / *"upstream changed"* — when an edit made its last result stale, naming the variables that drifted.
-
-### 🔀 Merge & compare
-- **Visual merge contracts.** Combine branches by **clicking the variables you want** right in each branch's code — hover to trace every occurrence, click to add it to the merge. No copy-paste, no name clashes.
-- Merge cells receive their inputs across kernels via an explicit, editable contract.
-
-### 📓 Fits your existing workflow
-- **It's still Jupyter.** Real kernels, real outputs, MathJax, the works.
-- **Notebook side-view.** Open the linear notebook beside the graph any time.
-- **Export a path → `.ipynb`.** Pick a root-to-tip path and save it as an ordinary notebook to share or hand off.
+## Parallel execution
+
+Branches are independent, so ipyGraph runs them like an experiment *should* run: **shared prep once, models concurrently.**
+
+<p align="center"><img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/parallelism.png" alt="Fork-join parallelism: shared prep runs once, branches train in parallel on separate kernels, a merge compares them" width="820"></p>
+
+- **Fork-join, not replay.** *Run Parallel* on a 1-prep → 3-model graph runs the prep **once**, then trains the three models **at the same time**, each on its own fresh kernel. A 10-model bake-off pays for data loading once, not ten times.
+- **Fork-point kernel snapshots.** The kernel's state is saved at each branch point, so a sibling branch **resumes from a saved copy** instead of re-running the whole path — and the copy rolls forward as you iterate down a branch. Tweaking the deepest cell costs one cell's runtime plus a state restore.
+- **True isolation.** A branch's variables come only from its own path. One branch can never be polluted by code you ran on another — proven by identical results whether a branch runs alone or beside others.
+- **▶ Run** a single cell or **⇥ Run to here** to rebuild a path from scratch on a clean isolated kernel.
 
 ---
 
+## More features
+
+- 🕸️ **The graph is the interface.** Graph View is the default; flip any card between **Plan view** (titles + prose) and **Code view** (editors + outputs). Edit code, rename branches, and click-to-edit descriptions in place. Arrow-key navigation; a **👁 Watch agent** button pans to whatever the agent is touching.
+- 🤖 **Plan-first AI copilot.** Describe a goal → it drafts the plan on the graph, you approve, then it builds and iterates. Multi-agent: an architect-vs-critic debate picks the model shortlist; parallel coder sub-agents fill the branches. Finds data for you via a full-screen Kaggle dataset picker. Uses your Claude subscription (Claude Agent SDK, no API key) or an Anthropic/OpenAI/Gemini key.
+- 🔀 **Visual merge contracts.** Combine branches by **clicking the variables you want** in each branch's code — hover to trace every occurrence, click to add it to the merge. No copy-paste, no name clashes.
+- 🩺 **Staleness badges.** A cell warns you — *"changed after last run"* / *"upstream changed"* — when an edit made its last result stale, naming the variables that drifted.
+- 📓 **Still Jupyter.** Real kernels, outputs, MathJax. Open the linear notebook side-by-side, and export any path to a plain `.ipynb`.
+
 ## Why it's useful
 
-- **You never lose an experiment.** Every model you try is a branch you can see, re-run, and compare — not a commented-out block.
-- **Your results are actually reproducible.** Path isolation + "Run to here" means a number on a branch was produced by *that branch's code and nothing else*.
-- **Iteration is cheap.** Fork snapshots mean tweaking the deepest cell costs one cell's runtime plus a state restore — not a full re-run of the pipeline. Expensive data prep is paid for **once**, even across parallel model trainings.
-- **The graph is self-documenting.** Plan view + descriptions turn a notebook into something a teammate (or future you) can read top to bottom.
-- **AI does the busywork, you keep control.** The agent plans, codes, runs, and compares; you approve the plan and own the graph.
+- **You never lose an experiment** — every model you try is a branch you can see, re-run, and compare.
+- **Results are actually reproducible** — path isolation + "Run to here" means a number came from *that branch's code and nothing else*.
+- **Iteration is cheap** — fork snapshots + fork-join mean expensive prep is paid for once and deep edits re-run one cell.
+- **The graph is self-documenting** — Plan view turns a notebook into something a teammate (or future you) can read top to bottom.
+- **AI does the busywork, you keep control** — it plans, codes, runs, and compares; you approve the plan and own the graph.
 
 Great for **ML engineers and researchers** running model bake-offs, feature-engineering sweeps, and architecture searches — anyone whose "quick experiment" notebook always spirals.
 
 ---
 
-## Install
+## Install & run
 
 ```bash
 pip install ipygraph
+jupytergraph                 # launches JupyterLab at /graph
 ```
 
-Then start JupyterLab and create a new **Graphbook (.ipygb)** from the launcher, or open an existing `.ipygb` file — it opens in Graph View by default.
+Then create a new **Graphbook (.ipygb)** from the launcher, or open an existing `.ipygb` — it opens in Graph View by default.
+
+**Requirements:** JupyterLab ≥ 4, Python ≥ 3.10. For the AI copilot, either the `claude` CLI (subscription login) or an API key for your provider. Kaggle dataset search needs Kaggle credentials (entered once, stored server-side).
 
-**Requirements:** JupyterLab >= 4.0.0, Python >= 3.10. For the AI copilot, either the `claude` CLI (subscription login) or an API key for your provider of choice. Kaggle dataset search needs Kaggle credentials (entered once, stored server-side).
+> `jupytergraph` is JupyterLab mounted at `/graph` with ipyGraph branding. Everything else — kernels, terminals, other extensions — works exactly as in JupyterLab.
 
 ## Quick start
 
-1. Launcher → **Graphbook (.ipygb)**.
-2. Open the **Assistant** panel and describe what you want to build — e.g. *"train tree and neural models to predict chess move quality, and iterate."*
+1. Run `jupytergraph`, then Launcher → **Graphbook (.ipygb)**.
+2. Open the **Assistant** and describe what to build — e.g. *"train tree and neural models to predict chess move quality, and iterate."*
 3. Approve the plan it draws on the graph → it builds, runs, and compares the branches.
 4. Fork your own branches, **Run Parallel**, and **Save a path as `.ipynb`** when you're happy.
 
@@ -337,26 +353,20 @@ Then start JupyterLab and create a new **Graphbook (.ipygb)** from the launcher,
 
 ## Development
 
-Note: You will need NodeJS to build the extension package. `jlpm` is JupyterLab's pinned version of yarn.
+You will need NodeJS to build the extension. `jlpm` is JupyterLab's pinned yarn.
 
 ```bash
-# From the repo root: set up a dev environment
-python -m venv .venv
-source .venv/bin/activate
+python -m venv .venv && source .venv/bin/activate
 pip install --editable "."
-
-# Link the dev build into JupyterLab
 jupyter labextension develop . --overwrite
-
-# Rebuild the TypeScript after changes
-jlpm build
+jlpm build          # rebuild the TypeScript after changes
 ```
 
-Watch mode (rebuild on save) in one terminal, JupyterLab in another:
+Watch mode (rebuild on save) in one terminal, the app in another:
 
 ```bash
 jlpm watch
-jupyter lab
+jupytergraph
 ```
 
 Tests: `jlpm test` (Jest) and Playwright/Galata integration tests under [`ui-tests`](./ui-tests/README.md). Packaging: see [RELEASE](RELEASE.md).

ipygraph-1.14.1/README.md

@@ -0,0 +1,158 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/logo-banner.png" alt="ipyGraph — Notebooks that branch" width="620">
+</p>
+
+<p align="center"><b>Turn your Jupyter notebook into a branching graph of experiments.</b></p>
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/plan-view-detail.png" alt="ipyGraph plan view — a chess evaluation model built as a branching graph of self-describing steps" width="820">
+</p>
+
+[![Build](https://github.com/jupyterlab/jupyterlab-ipygb/workflows/Build/badge.svg)](https://github.com/jupyterlab/jupyterlab-ipygb/actions/workflows/build.yml)
+&nbsp;JupyterLab 4 · `.ipygb` file format · runs at `/graph` · source-available
+
+---
+
+## The problem
+
+Every ML notebook starts clean and ends as a 2,000-line scroll of dead cells, half-tried models, and *"wait — which run produced this number?"* You try five approaches, comment out four, lose track of which features fed which model, and can never reproduce the good result. AI can write the code for you now — but your **experiments** are still a linear mess.
+
+Notebooks are linear. **Experimentation isn't.**
+
+## What ipyGraph is
+
+**ipyGraph** (a.k.a. *Graphbook*) is a JupyterLab 4 extension that turns a notebook into a **branching DAG of cells**. Every experiment is a *branch* on a living graph instead of a copy-pasted block you'll never find again. A shared data-prep step forks into competing models; each branch keeps its own state; you compare tips and keep the winner.
+
+It ships with a **plan-first AI copilot** that designs the experiment graph, writes the code, runs it, and iterates — and an execution engine where **one branch can never silently contaminate another**.
+
+You launch it with its own command and it opens at `/graph`:
+
+```bash
+pip install ipygraph
+jupytergraph          # opens JupyterLab at http://localhost:8888/graph
+```
+
+## The `.ipygb` file format
+
+ipyGraph adds a new document type: **`.ipygb`** (a "Graphbook"). It's a **superset of the Jupyter notebook format** — the same `nbformat` JSON with cells, outputs, and metadata — with a little extra per-cell `ipygb` metadata that records the graph:
+
+```jsonc
+"metadata": {
+  "ipygb": {
+    "parent_id": "root-1",        // which cell's outputs this one builds on
+    "branch_name": "encode-nn",   // the branch this cell starts (optional)
+    "parent_ids": ["a", "b"],     // 2+ parents = a merge cell
+    "description": "…",           // shown in Plan view
+    "inputs": { … }               // explicit variables a merge consumes
+  }
+}
+```
+
+Because it's a superset, the kernel, outputs, and rendering are ordinary Jupyter — nothing proprietary about how your code runs. And you can always **export any root→tip path back to a plain `.ipynb`** to share or hand off.
+
+---
+
+## See it
+
+The screenshots below are a real ipyGraph project — *predicting a chess engine's position evaluation from the board.* A shared prep step splits into two feature representations (tabular vs. board-planes), which feed different model families.
+
+**Plan view — the whole experiment reads like a flowchart, and every step documents itself:**
+
+<p align="center"><img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/graph-plan-view.png" alt="Plan view: the full experiment graph" width="820"></p>
+
+**Code view — those same nodes are real, runnable Jupyter cells with live outputs:**
+
+<p align="center"><img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/graph-code-view.png" alt="Code view: the same graph as runnable cells" width="820"></p>
+
+**The AI copilot builds and iterates on the graph beside you (Autopilot is on by default):**
+
+<p align="center"><img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/graph-with-assistant.png" alt="ipyGraph assistant panel with a live conversation" width="820"></p>
+
+---
+
+## Parallel execution
+
+Branches are independent, so ipyGraph runs them like an experiment *should* run: **shared prep once, models concurrently.**
+
+<p align="center"><img src="https://raw.githubusercontent.com/anishchelliahcr/ipygraph-assets/main/parallelism.png" alt="Fork-join parallelism: shared prep runs once, branches train in parallel on separate kernels, a merge compares them" width="820"></p>
+
+- **Fork-join, not replay.** *Run Parallel* on a 1-prep → 3-model graph runs the prep **once**, then trains the three models **at the same time**, each on its own fresh kernel. A 10-model bake-off pays for data loading once, not ten times.
+- **Fork-point kernel snapshots.** The kernel's state is saved at each branch point, so a sibling branch **resumes from a saved copy** instead of re-running the whole path — and the copy rolls forward as you iterate down a branch. Tweaking the deepest cell costs one cell's runtime plus a state restore.
+- **True isolation.** A branch's variables come only from its own path. One branch can never be polluted by code you ran on another — proven by identical results whether a branch runs alone or beside others.
+- **▶ Run** a single cell or **⇥ Run to here** to rebuild a path from scratch on a clean isolated kernel.
+
+---
+
+## More features
+
+- 🕸️ **The graph is the interface.** Graph View is the default; flip any card between **Plan view** (titles + prose) and **Code view** (editors + outputs). Edit code, rename branches, and click-to-edit descriptions in place. Arrow-key navigation; a **👁 Watch agent** button pans to whatever the agent is touching.
+- 🤖 **Plan-first AI copilot.** Describe a goal → it drafts the plan on the graph, you approve, then it builds and iterates. Multi-agent: an architect-vs-critic debate picks the model shortlist; parallel coder sub-agents fill the branches. Finds data for you via a full-screen Kaggle dataset picker. Uses your Claude subscription (Claude Agent SDK, no API key) or an Anthropic/OpenAI/Gemini key.
+- 🔀 **Visual merge contracts.** Combine branches by **clicking the variables you want** in each branch's code — hover to trace every occurrence, click to add it to the merge. No copy-paste, no name clashes.
+- 🩺 **Staleness badges.** A cell warns you — *"changed after last run"* / *"upstream changed"* — when an edit made its last result stale, naming the variables that drifted.
+- 📓 **Still Jupyter.** Real kernels, outputs, MathJax. Open the linear notebook side-by-side, and export any path to a plain `.ipynb`.
+
+## Why it's useful
+
+- **You never lose an experiment** — every model you try is a branch you can see, re-run, and compare.
+- **Results are actually reproducible** — path isolation + "Run to here" means a number came from *that branch's code and nothing else*.
+- **Iteration is cheap** — fork snapshots + fork-join mean expensive prep is paid for once and deep edits re-run one cell.
+- **The graph is self-documenting** — Plan view turns a notebook into something a teammate (or future you) can read top to bottom.
+- **AI does the busywork, you keep control** — it plans, codes, runs, and compares; you approve the plan and own the graph.
+
+Great for **ML engineers and researchers** running model bake-offs, feature-engineering sweeps, and architecture searches — anyone whose "quick experiment" notebook always spirals.
+
+---
+
+## Install & run
+
+```bash
+pip install ipygraph
+jupytergraph                 # launches JupyterLab at /graph
+```
+
+Then create a new **Graphbook (.ipygb)** from the launcher, or open an existing `.ipygb` — it opens in Graph View by default.
+
+**Requirements:** JupyterLab ≥ 4, Python ≥ 3.10. For the AI copilot, either the `claude` CLI (subscription login) or an API key for your provider. Kaggle dataset search needs Kaggle credentials (entered once, stored server-side).
+
+> `jupytergraph` is JupyterLab mounted at `/graph` with ipyGraph branding. Everything else — kernels, terminals, other extensions — works exactly as in JupyterLab.
+
+## Quick start
+
+1. Run `jupytergraph`, then Launcher → **Graphbook (.ipygb)**.
+2. Open the **Assistant** and describe what to build — e.g. *"train tree and neural models to predict chess move quality, and iterate."*
+3. Approve the plan it draws on the graph → it builds, runs, and compares the branches.
+4. Fork your own branches, **Run Parallel**, and **Save a path as `.ipynb`** when you're happy.
+
+---
+
+## Development
+
+You will need NodeJS to build the extension. `jlpm` is JupyterLab's pinned yarn.
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install --editable "."
+jupyter labextension develop . --overwrite
+jlpm build          # rebuild the TypeScript after changes
+```
+
+Watch mode (rebuild on save) in one terminal, the app in another:
+
+```bash
+jlpm watch
+jupytergraph
+```
+
+Tests: `jlpm test` (Jest) and Playwright/Galata integration tests under [`ui-tests`](./ui-tests/README.md). Packaging: see [RELEASE](RELEASE.md).
+
+---
+
+## License
+
+**ipyGraph / Graphbook** is **source-available**, not OSI open source. See [`LICENSE`](./LICENSE) for the full terms and [`NOTICE`](./NOTICE) for third-party components.
+
+- **Free for individuals and any non-commercial use** — development, evaluation, personal projects, academic research, and teaching.
+- **Free for an organization's internal use up to 20 users (seats).**
+- **A paid commercial license (with a 5% royalty) is required** to charge for something built on it, offer it as a hosted/SaaS service, or exceed 20 internal users. Contact **anishchelliah.cr@gmail.com** to arrange one.
+
+This license covers only this project's own code. JupyterLab, Lumino, React, and other dependencies keep their own licenses (see [`NOTICE`](./NOTICE)); nothing here changes them.

{ipygraph-0.1.2 → ipygraph-1.14.1}/myextension/_version.py

@@ -1,4 +1,4 @@
 # This file is auto-generated by Hatchling. As such, do not:
 #   - modify
 #   - track in version control e.g. be sure to add to .gitignore
-__version__ = VERSION = '0.1.2'
+__version__ = VERSION = '1.14.1'

ipygraph-1.14.1/myextension/app.py

@@ -0,0 +1,29 @@
+"""
+`jupytergraph` — launch a JupyterLab server branded for ipyGraph and served
+at /graph instead of /lab.
+
+Same JupyterLab under the hood, just mounted at /graph so the product feels
+like its own tool rather than "a JupyterLab extension". The server loads
+JupyterLab via its own entry point, so a subclass's traits don't reach the
+mounted app — the reliable lever is `LabApp.app_url` config, which we
+default to /graph (still overridable on the command line).
+"""
+import sys
+
+from jupyterlab.labapp import LabApp
+
+GRAPH_URL = "/graph"
+
+
+def main():
+    argv = sys.argv[1:]
+    # Default the mount + landing page to /graph unless the user overrode it.
+    if not any(a.startswith("--LabApp.app_url") for a in argv):
+        argv = [f"--LabApp.app_url={GRAPH_URL}"] + argv
+    if not any(a.startswith("--LabApp.default_url") for a in argv):
+        argv = [f"--LabApp.default_url={GRAPH_URL}"] + argv
+    LabApp.launch_instance(argv=argv)
+
+
+if __name__ == "__main__":
+    main()

{ipygraph-0.1.2 → ipygraph-1.14.1}/myextension/labextension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myextension",
-  "version": "0.1.2",
+  "version": "1.14.1",
   "description": "Turn your Jupyter notebook into a branching graph of experiments — a JupyterLab extension with a plan-first AI copilot, branch isolation, and fork-join parallel execution.",
   "keywords": [
     "jupyter",
@@ -126,7 +126,7 @@
     "extension": true,
     "outputDir": "myextension/labextension",
     "_build": {
-      "load": "static/remoteEntry.358ed3d3675a8367.js",
+      "load": "static/remoteEntry.ec753dbe935c4f70.js",
       "extension": "./extension",
       "style": "./style"
     }

ipygraph-0.1.2/myextension/labextension/static/694.cb943d1ae1290ce8.js → ipygraph-1.14.1/myextension/labextension/static/694.255a445d5c77b9d5.js

@@ -1,4 +1,4 @@
-"use strict";(self.rspackChunkmyextension=self.rspackChunkmyextension||[]).push([[694],{7549(e,t,n){n.r(t),n.d(t,{default:()=>eY});var l=n(4064),i=n(277),o=n(1404),s=n(9643),a=n(49),r=n(2012),d=n(2200),c=n(1758),p=n(8705),h=n(9996),u=n(5285),g=n(9645),f=n(7989),m=n(1660),y=n(4207);async function _(e,t={}){let n=y.ServerConnection.makeSettings(),l=o.URLExt.join(n.baseUrl,"ipygb",...e.split("/")),i=await y.ServerConnection.makeRequest(l,t,n),s={};try{s=await i.json()}catch(e){}if(!i.ok)throw Error(s.error||`HTTP ${i.status}`);return s}function b(e){return _("agent/config",{method:"POST",body:JSON.stringify(e)})}function v(e){return _(`kaggle/search?q=${encodeURIComponent(e)}`)}function x(e){return _("kaggle/download",{method:"POST",body:JSON.stringify({ref:e})})}function w(e){return _(`kaggle/files?ref=${encodeURIComponent(e)}`)}function C(e){return _("agent",{method:"POST",body:JSON.stringify(e)})}function k(e){let t=[],n=e=>{e&&!t.includes(e)&&t.push(e)};for(let t of e.split("\n")){if(/^\s/.test(t)||/^\s*#/.test(t))continue;let e=t.match(/^([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)\s*(?::[^=]+)?\s*(?:[-+*/|&^%@]|\/\/|\*\*|<<|>>)?=(?!=)/);if(e){e[1].split(",").forEach(e=>n(e.trim()));continue}if(e=t.match(/^(?:def|class)\s+([A-Za-z_]\w*)/)){n(e[1]);continue}(e=t.match(/^for\s+([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)\s+in\s/))&&e[1].split(",").forEach(e=>n(e.trim()))}return t}let E=`
+"use strict";(self.rspackChunkmyextension=self.rspackChunkmyextension||[]).push([[694],{7549(e,t,n){n.r(t),n.d(t,{default:()=>eY});var l=n(4064),i=n(277),o=n(1404),s=n(2024),a=n(49),r=n(2012),d=n(2200),c=n(1758),p=n(8705),h=n(9996),u=n(5285),g=n(9645),f=n(7989),m=n(1660),y=n(4207);async function _(e,t={}){let n=y.ServerConnection.makeSettings(),l=o.URLExt.join(n.baseUrl,"ipygb",...e.split("/")),i=await y.ServerConnection.makeRequest(l,t,n),s={};try{s=await i.json()}catch(e){}if(!i.ok)throw Error(s.error||`HTTP ${i.status}`);return s}function b(e){return _("agent/config",{method:"POST",body:JSON.stringify(e)})}function v(e){return _(`kaggle/search?q=${encodeURIComponent(e)}`)}function x(e){return _("kaggle/download",{method:"POST",body:JSON.stringify({ref:e})})}function w(e){return _(`kaggle/files?ref=${encodeURIComponent(e)}`)}function C(e){return _("agent",{method:"POST",body:JSON.stringify(e)})}function k(e){let t=[],n=e=>{e&&!t.includes(e)&&t.push(e)};for(let t of e.split("\n")){if(/^\s/.test(t)||/^\s*#/.test(t))continue;let e=t.match(/^([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)\s*(?::[^=]+)?\s*(?:[-+*/|&^%@]|\/\/|\*\*|<<|>>)?=(?!=)/);if(e){e[1].split(",").forEach(e=>n(e.trim()));continue}if(e=t.match(/^(?:def|class)\s+([A-Za-z_]\w*)/)){n(e[1]);continue}(e=t.match(/^for\s+([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)\s+in\s/))&&e[1].split(",").forEach(e=>n(e.trim()))}return t}let E=`
 def __ipygb_inspect():
     import json, types
     out = []