PyPI - nbdevAuto - Versions diffs - 0.3.67__tar.gz → 0.3.69__tar.gz - Mend

nbdevAuto 0.3.67tar.gz → 0.3.69tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

{nbdevauto-0.3.67/nbdevAuto.egg-info → nbdevauto-0.3.69}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nbdevAuto
-Version: 0.3.67
+Version: 0.3.69
 Summary: automating nbdev
 Author-email: Benedict Thekkel <bthekkel1@gmail.com>
 License-Expression: Apache-2.0
@@ -70,26 +70,28 @@ from nbdevAuto.pdf import PDFreader
 | Page | Covers |
 |----|----|
 | [Functions](00_Functions.ipynb) | Dataset and image helpers: reading a list out of a text file, downloading single images or whole search-driven datasets, verifying and resizing what came back, building the folder layout a classifier expects, running a fastai learner over one image, Kaggle competition and dataset shortcuts, and [`graph`](https://bthek1.github.io/nbdevAuto/functions.html#graph), a `graphviz.Digraph` subclass preloaded with a rounded, filled style |
-| [Automate](01_Automate.ipynb) | The command line surface: the prep/commit/push pipeline, the GitHub and PyPI release halves, and the help output that lists them all |
+| [Automate](01_Automate.ipynb) | The command line surface: the prep/commit/push pipeline, the GitHub and PyPI release halves, the help output that lists them all, and the one-line-per-stage console grid every command reports through |
 | [PDF Reader](02_PDF_reader.ipynb) | [`PDFreader`](https://bthek1.github.io/nbdevAuto/pdf_reader.html#pdfreader), a class that converts a PDF through `pdf2image` and renders page ranges inline when you slice it (`pdf[0:5]`) |
-| [GitHub](03_GitHub.ipynb) | [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus): reading `.gitmodules`, resolving a token, and asking the GitHub API about every submodule at once - CI runs, Pages deploys, Pages builds, remote `main` shas - plus the `--report` and `--audit` views and the exit codes that keep “absent” apart from “cannot ask” |
+| [GitHub](03_GitHub.ipynb) | [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus): reading `.gitmodules`, resolving a token, and asking the GitHub API about every submodule at once - CI runs, Pages deploys, Pages builds, remote `main` shas - plus the `--report` and `--audit` views, the exit codes that keep “absent” apart from “cannot ask”, and `newest_run`, which picks a run by `run_number` because the API’s page order is not a contract |
+| [Fleet](04_Fleet.ipynb) | [`fleet`](https://bthek1.github.io/nbdevAuto/fleet.html#fleet): running one command across every submodule of a superproject. A walker that reports only what did work and counts the rest, plus the verbs built on it - upload, push, copy, status, update and sync |
 ------------------------------------------------------------------------
 ## The Command Line Surface
-Installing the package puts these on your `PATH`. Most are ordinary functions in [Automate](01_Automate.ipynb), exposed as scripts through `[project.scripts]`; [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus) comes from [GitHub](03_GitHub.ipynb).
+Installing the package puts these on your `PATH`. Most are ordinary functions in [Automate](01_Automate.ipynb), exposed as scripts through `[project.scripts]`; [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus) comes from [GitHub](03_GitHub.ipynb) and [`fleet`](https://bthek1.github.io/nbdevAuto/fleet.html#fleet) from [Fleet](04_Fleet.ipynb).
 | Command | Does |
 |----|----|
 | [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) | Bump the version, then export, test and clean the notebooks, refreshing `_quarto.yml` and the README |
-| [`gacp`](https://bthek1.github.io/nbdevAuto/automate.html#gacp) | git add, commit, and push. Without `-m` the commit message is the status output |
+| [`gacp`](https://bthek1.github.io/nbdevAuto/automate.html#gacp) | git add, commit, and push. Without `-m` the message is built from the staged paths |
 | [`status`](https://bthek1.github.io/nbdevAuto/automate.html#status) | Show the working tree state |
 | [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) | [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) then [`gacp`](https://bthek1.github.io/nbdevAuto/automate.html#gacp), the one you actually type |
 | `gitrelease` | Bump the **minor** version, then tag and create a GitHub release |
 | `piprelease` | Build the sdist and wheel, then upload to PyPI with twine |
 | [`release`](https://bthek1.github.io/nbdevAuto/automate.html#release) | `gitrelease` then `piprelease` |
 | [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus) | Remote status for every submodule of an nbdev superproject, from the GitHub API. `--report` for the sync view, `--audit` to check `.gitmodules` against the repos the account owns, `--json` for machine output |
+| [`fleet`](https://bthek1.github.io/nbdevAuto/fleet.html#fleet) | Run one command across every submodule: `fleet upload|push|copy|status|update|sync`. Every verb takes `--help`, and the destructive ones take `--dry-run` |
 | `h` | Print the list of available commands |
 Both [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) and [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) take `-p` to choose which version part to increment; it defaults to 2, the patch, so every [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) ships a new version.
@@ -100,6 +102,25 @@ Both [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) and [`uploa
 ------------------------------------------------------------------------
+## The Output Contract
+Every command reports through one grid, defined in [Automate](01_Automate.ipynb) and reused by [Fleet](04_Fleet.ipynb). It exists because these commands run 19 times in a row, so anything that costs three lines per stage costs sixty over a fleet.
+    1/6  bump version (part 2)  OK       75ms  0.3.67 -> 0.3.68
+    2/6  nbdev_export           OK      129ms
+    3/6  nbdev_test             OK       1.5s  6 notebooks, slowest 01_Automate.ipynb 1.0s
+Four rules hold it together, and a change to any stage has to keep them:
+- **One stage, one line, inside 88 columns.** The columns are fixed: `n/total` (5), label (22), outcome (4), duration (7), detail (the rest). A unit test renders real stages through a console pinned to that width and asserts every line fits.
+- **A summariser returns short strings, not a transcript.** [`_test_summary`](https://bthek1.github.io/nbdevAuto/automate.html#_test_summary) turns a line per notebook into `6 notebooks, slowest X 1.0s`; [`_push_summary`](https://bthek1.github.io/nbdevAuto/automate.html#_push_summary) turns nine lines of git progress into a sha range and a size. Anything too long for the detail column moves to an indented continuation line, so a verbose summariser degrades the layout rather than breaking it.
+- **A stage that shells out must capture at the file-descriptor level.** `redirect_stdout` only rebinds Python’s `sys.stdout`, so a child process writing to fd 1 walks straight past it - which is how `nbdev_readme` used to spill sixteen lines of pandoc metadata into the middle of a run. [`_quiet`](https://bthek1.github.io/nbdevAuto/automate.html#_quiet) swaps fds 1 and 2 for a temp file as well and merges both captures.
+- **A green OK has to mean something.** [`_run`](https://bthek1.github.io/nbdevAuto/automate.html#_run) raises on a non-zero exit rather than returning a code nobody reads, and the failure prints the command’s own output. Before that, a failed `git push` still reported `OK`.
+On a terminal the label is written first without a newline, so a slow stage is visible while it runs, then rewritten in place. Piped output skips that entirely, because a carriage return in a log file is just noise.
+------------------------------------------------------------------------
 ## Where It Is Used
 The parent Knowledge repo’s `justfile` calls [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) once per submodule. `just upload` runs it only where the working tree is dirty, `just full_upload` runs it everywhere. That is the main consumer, so a change to `automate.py` affects the publish path for every site in the collection.
@@ -116,9 +137,10 @@ Because [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) bump
 ## Not Covered Yet
-- **No test notebook for the helpers.** `03_GitHub.ipynb` carries unit tests for its pure functions, but the dataset and image helpers are exercised only by being used, so a broken one surfaces in a downstream repo rather than here.
+- **No tests for the helpers.** `01_Automate.ipynb`, `03_GitHub.ipynb` and `04_Fleet.ipynb` all carry unit tests for their pure functions - the fleet ones against a throwaway superproject of real git repos - but the dataset and image helpers in `00_Functions.ipynb` are exercised only by being used, so a broken one surfaces in a downstream repo rather than here.
 - **Undeclared dependencies.** `pyproject.toml` declares `graphviz` and `fastcore`, plus `githubkit` behind the `gh` extra. The helpers additionally import `fastai`, `fastbook`, `fastdownload`, `PIL`, `matplotlib`, `tqdm`, `pdf2image` (with poppler behind it), `nbdev` and `kaggle` (which also needs its credentials). All of those are imported lazily inside the function that needs them, so installing the package and running the console scripts still works - only the specific helper you call fails. Install them yourself.
 - **`core.py` is an empty nbdev stub** (a single `foo`) left over from `00_core.ipynb`, which no longer exists.
+- **`CHANGELOG.md` is still the nbdev stub** (`Version 1.0.0 - Initial release`) while the package is past 0.3.68. Nothing generates it, and [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) bumps the patch on every push, so it would need writing by hand or dropping.
 - The docstrings are one-liners, so the rendered API pages are thin. The notebooks carry the real explanation.
 ------------------------------------------------------------------------

{nbdevauto-0.3.67 → nbdevauto-0.3.69}/README.md RENAMED Viewed

@@ -40,26 +40,28 @@ from nbdevAuto.pdf import PDFreader
 | Page | Covers |
 |----|----|
 | [Functions](00_Functions.ipynb) | Dataset and image helpers: reading a list out of a text file, downloading single images or whole search-driven datasets, verifying and resizing what came back, building the folder layout a classifier expects, running a fastai learner over one image, Kaggle competition and dataset shortcuts, and [`graph`](https://bthek1.github.io/nbdevAuto/functions.html#graph), a `graphviz.Digraph` subclass preloaded with a rounded, filled style |
-| [Automate](01_Automate.ipynb) | The command line surface: the prep/commit/push pipeline, the GitHub and PyPI release halves, and the help output that lists them all |
+| [Automate](01_Automate.ipynb) | The command line surface: the prep/commit/push pipeline, the GitHub and PyPI release halves, the help output that lists them all, and the one-line-per-stage console grid every command reports through |
 | [PDF Reader](02_PDF_reader.ipynb) | [`PDFreader`](https://bthek1.github.io/nbdevAuto/pdf_reader.html#pdfreader), a class that converts a PDF through `pdf2image` and renders page ranges inline when you slice it (`pdf[0:5]`) |
-| [GitHub](03_GitHub.ipynb) | [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus): reading `.gitmodules`, resolving a token, and asking the GitHub API about every submodule at once - CI runs, Pages deploys, Pages builds, remote `main` shas - plus the `--report` and `--audit` views and the exit codes that keep “absent” apart from “cannot ask” |
+| [GitHub](03_GitHub.ipynb) | [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus): reading `.gitmodules`, resolving a token, and asking the GitHub API about every submodule at once - CI runs, Pages deploys, Pages builds, remote `main` shas - plus the `--report` and `--audit` views, the exit codes that keep “absent” apart from “cannot ask”, and `newest_run`, which picks a run by `run_number` because the API’s page order is not a contract |
+| [Fleet](04_Fleet.ipynb) | [`fleet`](https://bthek1.github.io/nbdevAuto/fleet.html#fleet): running one command across every submodule of a superproject. A walker that reports only what did work and counts the rest, plus the verbs built on it - upload, push, copy, status, update and sync |
 ------------------------------------------------------------------------
 ## The Command Line Surface
-Installing the package puts these on your `PATH`. Most are ordinary functions in [Automate](01_Automate.ipynb), exposed as scripts through `[project.scripts]`; [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus) comes from [GitHub](03_GitHub.ipynb).
+Installing the package puts these on your `PATH`. Most are ordinary functions in [Automate](01_Automate.ipynb), exposed as scripts through `[project.scripts]`; [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus) comes from [GitHub](03_GitHub.ipynb) and [`fleet`](https://bthek1.github.io/nbdevAuto/fleet.html#fleet) from [Fleet](04_Fleet.ipynb).
 | Command | Does |
 |----|----|
 | [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) | Bump the version, then export, test and clean the notebooks, refreshing `_quarto.yml` and the README |
-| [`gacp`](https://bthek1.github.io/nbdevAuto/automate.html#gacp) | git add, commit, and push. Without `-m` the commit message is the status output |
+| [`gacp`](https://bthek1.github.io/nbdevAuto/automate.html#gacp) | git add, commit, and push. Without `-m` the message is built from the staged paths |
 | [`status`](https://bthek1.github.io/nbdevAuto/automate.html#status) | Show the working tree state |
 | [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) | [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) then [`gacp`](https://bthek1.github.io/nbdevAuto/automate.html#gacp), the one you actually type |
 | `gitrelease` | Bump the **minor** version, then tag and create a GitHub release |
 | `piprelease` | Build the sdist and wheel, then upload to PyPI with twine |
 | [`release`](https://bthek1.github.io/nbdevAuto/automate.html#release) | `gitrelease` then `piprelease` |
 | [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus) | Remote status for every submodule of an nbdev superproject, from the GitHub API. `--report` for the sync view, `--audit` to check `.gitmodules` against the repos the account owns, `--json` for machine output |
+| [`fleet`](https://bthek1.github.io/nbdevAuto/fleet.html#fleet) | Run one command across every submodule: `fleet upload|push|copy|status|update|sync`. Every verb takes `--help`, and the destructive ones take `--dry-run` |
 | `h` | Print the list of available commands |
 Both [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) and [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) take `-p` to choose which version part to increment; it defaults to 2, the patch, so every [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) ships a new version.
@@ -70,6 +72,25 @@ Both [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) and [`uploa
 ------------------------------------------------------------------------
+## The Output Contract
+Every command reports through one grid, defined in [Automate](01_Automate.ipynb) and reused by [Fleet](04_Fleet.ipynb). It exists because these commands run 19 times in a row, so anything that costs three lines per stage costs sixty over a fleet.
+    1/6  bump version (part 2)  OK       75ms  0.3.67 -> 0.3.68
+    2/6  nbdev_export           OK      129ms
+    3/6  nbdev_test             OK       1.5s  6 notebooks, slowest 01_Automate.ipynb 1.0s
+Four rules hold it together, and a change to any stage has to keep them:
+- **One stage, one line, inside 88 columns.** The columns are fixed: `n/total` (5), label (22), outcome (4), duration (7), detail (the rest). A unit test renders real stages through a console pinned to that width and asserts every line fits.
+- **A summariser returns short strings, not a transcript.** [`_test_summary`](https://bthek1.github.io/nbdevAuto/automate.html#_test_summary) turns a line per notebook into `6 notebooks, slowest X 1.0s`; [`_push_summary`](https://bthek1.github.io/nbdevAuto/automate.html#_push_summary) turns nine lines of git progress into a sha range and a size. Anything too long for the detail column moves to an indented continuation line, so a verbose summariser degrades the layout rather than breaking it.
+- **A stage that shells out must capture at the file-descriptor level.** `redirect_stdout` only rebinds Python’s `sys.stdout`, so a child process writing to fd 1 walks straight past it - which is how `nbdev_readme` used to spill sixteen lines of pandoc metadata into the middle of a run. [`_quiet`](https://bthek1.github.io/nbdevAuto/automate.html#_quiet) swaps fds 1 and 2 for a temp file as well and merges both captures.
+- **A green OK has to mean something.** [`_run`](https://bthek1.github.io/nbdevAuto/automate.html#_run) raises on a non-zero exit rather than returning a code nobody reads, and the failure prints the command’s own output. Before that, a failed `git push` still reported `OK`.
+On a terminal the label is written first without a newline, so a slow stage is visible while it runs, then rewritten in place. Piped output skips that entirely, because a carriage return in a log file is just noise.
+------------------------------------------------------------------------
 ## Where It Is Used
 The parent Knowledge repo’s `justfile` calls [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) once per submodule. `just upload` runs it only where the working tree is dirty, `just full_upload` runs it everywhere. That is the main consumer, so a change to `automate.py` affects the publish path for every site in the collection.
@@ -86,9 +107,10 @@ Because [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) bump
 ## Not Covered Yet
-- **No test notebook for the helpers.** `03_GitHub.ipynb` carries unit tests for its pure functions, but the dataset and image helpers are exercised only by being used, so a broken one surfaces in a downstream repo rather than here.
+- **No tests for the helpers.** `01_Automate.ipynb`, `03_GitHub.ipynb` and `04_Fleet.ipynb` all carry unit tests for their pure functions - the fleet ones against a throwaway superproject of real git repos - but the dataset and image helpers in `00_Functions.ipynb` are exercised only by being used, so a broken one surfaces in a downstream repo rather than here.
 - **Undeclared dependencies.** `pyproject.toml` declares `graphviz` and `fastcore`, plus `githubkit` behind the `gh` extra. The helpers additionally import `fastai`, `fastbook`, `fastdownload`, `PIL`, `matplotlib`, `tqdm`, `pdf2image` (with poppler behind it), `nbdev` and `kaggle` (which also needs its credentials). All of those are imported lazily inside the function that needs them, so installing the package and running the console scripts still works - only the specific helper you call fails. Install them yourself.
 - **`core.py` is an empty nbdev stub** (a single `foo`) left over from `00_core.ipynb`, which no longer exists.
+- **`CHANGELOG.md` is still the nbdev stub** (`Version 1.0.0 - Initial release`) while the package is past 0.3.68. Nothing generates it, and [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) bumps the patch on every push, so it would need writing by hand or dropping.
 - The docstrings are one-liners, so the rendered API pages are thin. The notebooks carry the real explanation.
 ------------------------------------------------------------------------

nbdevauto-0.3.69/nbdevAuto/__init__.py ADDED Viewed

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

{nbdevauto-0.3.67 → nbdevauto-0.3.69}/nbdevAuto/_modidx.py RENAMED Viewed

@@ -13,13 +13,16 @@ d = { 'settings': { 'branch': 'main',
                                     'nbdevAuto.automate._commit_summary': ('automate.html#_commit_summary', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate._done': ('automate.html#_done', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate._dur': ('automate.html#_dur', 'nbdevAuto/automate.py'),
+                                    'nbdevAuto.automate._head': ('automate.html#_head', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate._push_summary': ('automate.html#_push_summary', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate._quiet': ('automate.html#_quiet', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate._rule': ('automate.html#_rule', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate._run': ('automate.html#_run', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate._skip': ('automate.html#_skip', 'nbdevAuto/automate.py'),
+                                    'nbdevAuto.automate._staged_summary': ('automate.html#_staged_summary', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate._status_table': ('automate.html#_status_table', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate._step': ('automate.html#_step', 'nbdevAuto/automate.py'),
+                                    'nbdevAuto.automate._tail': ('automate.html#_tail', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate._test_summary': ('automate.html#_test_summary', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate._version_summary': ('automate.html#_version_summary', 'nbdevAuto/automate.py'),
                                     'nbdevAuto.automate.gacp': ('automate.html#gacp', 'nbdevAuto/automate.py'),
@@ -111,6 +114,7 @@ d = { 'settings': { 'branch': 'main',
                                   'nbdevAuto.github.has_failure': ('github.html#has_failure', 'nbdevAuto/github.py'),
                                   'nbdevAuto.github.local_sha': ('github.html#local_sha', 'nbdevAuto/github.py'),
                                   'nbdevAuto.github.local_state': ('github.html#local_state', 'nbdevAuto/github.py'),
+                                  'nbdevAuto.github.newest_run': ('github.html#newest_run', 'nbdevAuto/github.py'),
                                   'nbdevAuto.github.owned_repos': ('github.html#owned_repos', 'nbdevAuto/github.py'),
                                   'nbdevAuto.github.parse_gitmodules': ('github.html#parse_gitmodules', 'nbdevAuto/github.py'),
                                   'nbdevAuto.github.repo_status': ('github.html#repo_status', 'nbdevAuto/github.py'),

{nbdevauto-0.3.67 → nbdevauto-0.3.69}/nbdevAuto/automate.py RENAMED Viewed

@@ -16,8 +16,11 @@ from rich.rule import Rule
 from rich.table import Table
 # %% ../nbs/01_Automate.ipynb #7c1e5a90-3f52-4d21-9b6a-2c0f4e8d1a37
+import os
 import re
 import subprocess
+import sys
+import tempfile
 from contextlib import contextmanager, redirect_stderr, redirect_stdout
 from io import StringIO
 from time import perf_counter
@@ -26,8 +29,16 @@ from nbdevAuto import __version__
 console = Console()
-# A rule drawn across a 200-column terminal is a wall of dashes. 88 reads as a header.
-_RULE_W = 88
+# One line per stage, inside 88 columns:
+#   "1/6  bump version (part 2)  OK      75ms  0.3.67 -> 0.3.68"
+#    NUM  LABEL                  STAT     DUR  detail
+_WIDTH   = 88
+_W_NUM   = 5
+_W_LABEL = 22
+_W_STAT  = 4
+_W_DUR   = 7
+_W_HEAD  = _W_NUM + _W_LABEL + 1 + _W_STAT + 1 + _W_DUR + 2
+_W_DETAIL = _WIDTH - _W_HEAD
 # `git status -s` codes: colour, the word for the third column, and the verb a commit
 # subject gets when every staged path carries that same code.
@@ -57,86 +68,117 @@ def _dur(t0):
     return f"{int(s)//60}m{int(s)%60:02d}s"
 def _rule(text, style):
-    "A rule capped at `_RULE_W`; `console.rule` otherwise spans the whole terminal"
-    console.print(Rule(text, style=style), width=min(console.width, _RULE_W))
+    "A rule capped at `_WIDTH`; `console.rule` otherwise spans the whole terminal"
+    console.print(Rule(text, style=style), width=min(console.width, _WIDTH))
 def _banner(cmd):
     "Command header, with the package version alongside"
     _rule(f"[bold cyan]{cmd}[/bold cyan] [dim]nbdevAuto {__version__}[/dim]", "cyan")
 def _done(cmd, t0):
-    "Closing summary for a multi-stage command"
-    _rule(f"[green]{cmd} finished[/green] [dim]in {_dur(t0)}[/dim]", "green")
+    "Closing line for a multi-stage command. A dim line, not another full-width rule"
+    console.print(f"[dim]{cmd} finished in {_dur(t0)}[/dim]")
+def _head(n, total, label):
+    "The fixed-width left side of a stage line"
+    return f"{f'{n}/{total}':<{_W_NUM}}{label:<{_W_LABEL}}"
+def _tail(detail):
+    "(text for the stage line, overflow lines). Detail is joined while it still fits"
+    if not detail: return "", []
+    joined = "; ".join(detail)
+    if len(joined) <= _W_DETAIL: return joined, []
+    return detail[0], detail[1:]
 @contextmanager
 def _step(n, total, label):
-    """Run one stage, reporting its outcome and duration.
-    Yields a list: append short strings and they print under the step, which is how a
-    stage says what it did without letting the underlying tool print it all. Re-raises
-    so nothing is swallowed, and a `StepFailed` shows the output it carries."""
-    console.print(f"[dim]{n}/{total}[/dim] [bold]{label}[/bold]")
+    """Run one stage and report it on a SINGLE line.
+    Yields a list; append short strings and they land in the detail column. On a terminal
+    the label is written first without a newline so a slow stage is visible while it runs,
+    then rewritten in place once the outcome is known. Piped output skips that, because a
+    carriage return in a log file is just noise."""
+    head = _head(n, total, label)
+    live = console.is_terminal
+    if live: console.print(head, end="", highlight=False)
     t0, detail = perf_counter(), []
+    def emit(stat, style, extra):
+        text, over = _tail(extra)
+        # Back to column 0 WITHOUT going through rich's renderer, which would escape the
+        # carriage return instead of acting on it and print the label twice.
+        if live: console.file.write("\r"); console.file.flush()
+        line = f"{head} [{style}]{stat:<{_W_STAT}}[/{style}] [dim]{_dur(t0):>{_W_DUR}}[/dim]"
+        if text: line += f"  [dim]{escape(text)}[/dim]"
+        console.print(line, highlight=False)
+        for o in over: console.print(f"    [dim]{escape(o)}[/dim]", highlight=False)
     try:
         yield detail
     except StepFailed as e:
-        console.print(f"    [bold red]FAIL[/bold red] [dim]{_dur(t0)}, exit {e.code}[/dim]")
+        emit("FAIL", "bold red", [])
         for line in e.output.splitlines():
-            if line.strip(): console.print(f"    [red]{escape(line.rstrip())}[/red]")
-        console.print()
+            if line.strip(): console.print(f"    [red]{escape(line.rstrip())}[/red]", highlight=False)
         raise
     except BaseException:
-        console.print(f"    [bold red]FAIL[/bold red] [dim]{_dur(t0)}[/dim]\n")
+        emit("FAIL", "bold red", [])
         raise
-    for line in detail: console.print(f"    [dim]{escape(line)}[/dim]")
-    console.print(f"    [green]OK[/green]   [dim]{_dur(t0)}[/dim]\n")
+    emit("OK", "green", detail)
 def _skip(n, total, label, why):
-    "Report a stage that was deliberately not run"
-    console.print(f"[dim]{n}/{total}[/dim] [bold]{label}[/bold]")
-    console.print(f"    [yellow]SKIP[/yellow] [dim]{why}[/dim]\n")
+    "Report a stage that was deliberately not run, on the same one-line grid"
+    console.print(f"{_head(n, total, label)} [yellow]{'SKIP':<{_W_STAT}}[/yellow] "
+                  f"[dim]{'-':>{_W_DUR}}[/dim]  [dim]{escape(why)}[/dim]", highlight=False)
 def _run(*cmd):
     """Run `cmd` with output captured, returning stdout+stderr.
     A bare `subprocess.run` returns an exit code nobody reads, so a failed `git push`
     still printed a green OK. Raising is what makes that OK mean something."""
-    r = subprocess.run(cmd, capture_output=True, text=True)
+    r = subprocess.run(cmd, capture_output=True, text=True, check=False)
     out = f"{r.stdout or ''}{r.stderr or ''}"
     if r.returncode: raise StepFailed(" ".join(cmd), r.returncode, out)
     return out
 @contextmanager
 def _quiet():
-    "Collect what a wrapped nbdev call prints, so the step can summarise it instead"
+    """Capture what a stage prints, INCLUDING what its subprocesses print.
+    `redirect_stdout` only rebinds Python's `sys.stdout`, so a child process writing
+    straight to file descriptor 1 sails past it - which is how `nbdev_readme` used to dump
+    sixteen lines of pandoc metadata into the middle of the run. Descriptors 1 and 2 are
+    therefore swapped for a temp file as well, and both captures are merged."""
     buf = StringIO()
-    try:
-        with redirect_stdout(buf), redirect_stderr(buf): yield buf
-    except BaseException:
-        # A failing stage is the one time every raw line is worth having.
-        text = buf.getvalue().strip()
-        if text: console.print(f"[dim]{escape(text)}[/dim]")
-        raise
+    with tempfile.TemporaryFile(mode="w+") as tmp:
+        sys.stdout.flush(); sys.stderr.flush()
+        saved = os.dup(1), os.dup(2)
+        os.dup2(tmp.fileno(), 1); os.dup2(tmp.fileno(), 2)
+        try:
+            with redirect_stdout(buf), redirect_stderr(buf): yield buf
+        finally:
+            sys.stdout.flush(); sys.stderr.flush()
+            os.dup2(saved[0], 1); os.dup2(saved[1], 2)
+            for fd in saved: os.close(fd)
+            tmp.seek(0)
+            buf.write(tmp.read())
 def _version_summary(out):
     "The two lines `nbdev_bump_version` prints, as one arrow"
     v = dict(_RE_VERSION.findall(out))
     if "Old" in v and "New" in v: return [f"{v['Old']} -> {v['New']}"]
-    return [l.strip() for l in out.splitlines() if l.strip()]
+    return [l.strip() for l in out.splitlines() if l.strip()][:1]
-def _test_summary(out, slow_secs=1.0, keep=3):
-    "`nbdev_test` prints a line per notebook; keep the count and only the genuinely slow ones"
+def _test_summary(out, slow_secs=1.0):
+    "`nbdev_test` prints a line per notebook; keep the count and the slowest one"
     times = []
     for line in out.splitlines():
         m = _RE_TIMING.match(line.strip())
         if m:
             try: times.append((m["nb"], float(m["secs"])))
             except ValueError: pass
-    if not times: return [l.strip() for l in out.splitlines() if l.strip()][-3:]
+    if not times: return [l.strip() for l in out.splitlines() if l.strip()][-1:]
     head = f"{len(times)} notebook{'' if len(times) == 1 else 's'}"
-    slow = [t for t in sorted(times, key=lambda t: -t[1]) if t[1] >= slow_secs][:keep]
-    if not slow: return [f"{head}, none slower than {slow_secs:g}s"]
-    return [f"{head}, slowest:"] + [f"  {nb} {s:.1f}s" for nb, s in slow]
+    nb, s = max(times, key=lambda t: t[1])
+    if s < slow_secs: return [f"{head}, all under {slow_secs:g}s"]
+    return [f"{head}, slowest {nb} {s:.1f}s"]
 def _commit_summary(out):
     "Where the commit landed and how big it was, without echoing the subject back"
@@ -146,20 +188,23 @@ def _commit_summary(out):
     head = f"{m['branch']} {m['sha']}" if m else lines[0]
     if not c: return [head]
     files, ins, dels = c.group(1), c.group(2) or "0", c.group(3) or "0"
-    return [f"{head}  {files} file{'' if files == '1' else 's'}, +{ins} -{dels}"]
+    return [f"{head}  {files} file{'' if files == '1' else 's'} +{ins} -{dels}"]
 def _push_summary(out):
-    "What moved and how much went over the wire; the progress meters are noise"
+    """What moved, and how much went over the wire.
+    The remote is deliberately left out: the progress meters are noise, and which repo
+    this is has already been said by the prompt or by the fleet's `==> path` heading."""
     lines = [l.rstrip() for l in out.splitlines() if l.strip()]
     if not lines: return ["nothing to push"]
     if any("Everything up-to-date" in l for l in lines): return ["everything up-to-date"]
     detail = []
     for i, l in enumerate(lines):
         if l.startswith("To ") and i + 1 < len(lines):
-            detail += [lines[i + 1].strip(), f"to {l[3:].strip()}"]
+            detail.append(lines[i + 1].strip())
             break
     m = _RE_WROTE.search(out)
-    if m: detail.append(f"{m['size'].strip()} written")
+    if m: detail.append(m["size"].strip())
     return detail or lines[-1:]
 def _auto_msg(porcelain, limit=3):
@@ -172,9 +217,22 @@ def _auto_msg(porcelain, limit=3):
     if len(names) > limit: head += f" and {len(names) - limit} more"
     return f"{verb} {head}"
+def _staged_summary(porcelain, width=_W_DETAIL):
+    "One line naming what is staged, trimmed to the detail column"
+    rows = [l[3:].strip().split(" -> ")[-1] for l in porcelain.splitlines() if l.strip()]
+    n = len(rows)
+    if not n: return []
+    shown, used = [], 0
+    for r in rows:
+        nxt = used + len(r) + 2
+        if shown and nxt > width - 12: break
+        shown.append(r); used = nxt
+    tail = f", +{n - len(shown)}" if len(shown) < n else ""
+    return [f"{n} staged: {', '.join(shown)}{tail}"]
 def _status_table(porcelain):
     "Render `git status -s` output as a table, one row per path"
-    t = Table(box=box.SIMPLE, show_header=False, pad_edge=False, expand=False)
+    t = Table(box=None, show_header=False, pad_edge=False, expand=False)
     t.add_column("code", no_wrap=True, justify="right")
     t.add_column("path", overflow="fold")
     t.add_column("what", style="dim", no_wrap=True)
@@ -225,19 +283,13 @@ def gacp(
     _banner("gacp")
     t0 = perf_counter()
-    with _step(1, 3, "git add"):
-        _run("git", "add", ".")
     # NOT via `_run`: `git status -s` pads the code to two columns, and the capture has
     # to keep that leading space or the first path shifts by one.
-    status = subprocess.check_output(["git", "status", "-s"]).decode('utf-8')
+    with _step(1, 3, "git add") as d:
+        _run("git", "add", ".")
+        status = subprocess.check_output(["git", "status", "-s"]).decode('utf-8')
+        d += _staged_summary(status)
     staged = bool(status.strip())
-    if staged:
-        table, n = _status_table(status)
-        console.print(table)
-        console.print(f"[dim]{n} path{'' if n == 1 else 's'} staged[/dim]\n")
-    else:
-        console.print("[dim]nothing staged, the tree is clean[/dim]\n")
     if staged:
         with _step(2, 3, "git commit") as d:
             d += _commit_summary(_run("git", "commit", "-m", m if m != '' else _auto_msg(status)))

{nbdevauto-0.3.67 → nbdevauto-0.3.69}/nbdevAuto/github.py RENAMED Viewed

@@ -6,8 +6,8 @@ Docs: https://bthek1.github.io/nbdevAuto/github.html.md"""
 # %% auto #0
 __all__ = ['Submodule', 'CI_WORKFLOWS', 'PAGES_WORKFLOWS', 'FAILED', 'RUNNING', 'BOLD', 'RED', 'YELLOW', 'CYAN', 'DIM', 'OFF',
-           'find_root', 'parse_gitmodules', 'resolve_token', 'local_sha', 'api_error', 'repo_status', 'client',
-           'gather_status', 'format_table', 'failures', 'has_failure', 'git', 'local_state', 'ahead_behind',
+           'find_root', 'parse_gitmodules', 'resolve_token', 'local_sha', 'api_error', 'newest_run', 'repo_status',
+           'client', 'gather_status', 'format_table', 'failures', 'has_failure', 'git', 'local_state', 'ahead_behind',
            'add_local', 'format_report', 'stale_sections', 'owned_repos', 'self_repo', 'audit_result', 'gather_audit',
            'format_audit', 'ghstatus']
@@ -93,19 +93,30 @@ def api_error(e):
 CI_WORKFLOWS    = ("test.yaml", "test.yml")       # fastai/workflows/nbdev3-ci
 PAGES_WORKFLOWS = ("deploy.yaml", "deploy.yml")   # fastai/workflows/quarto-ghp3
+def newest_run(runs):
+    """The newest run in `runs`, by `run_number`, which is monotonic per workflow.
+    Do NOT just take `runs[0]`. This endpoint is eventually consistent and its ordering is
+    not a contract: on 2026-08-26 a `per_page=1` query for ML_methods returned run number
+    96 (2026-02-17, failure) when 107 (2026-08-16, success) was the newest, and `just
+    report` called a healthy repo FAILURE. A single-item page gives the caller no way to
+    notice. Asking for several and taking the maximum costs the same one request."""
+    numbered = [r for r in runs if getattr(r, "run_number", None) is not None]
+    return max(numbered, key=lambda r: r.run_number) if numbered else runs[0]
 async def _latest_run(gh, sub, candidates, branch="main"):
     "Newest run of the first workflow in `candidates` that exists, or None"
     from githubkit.exception import RequestFailed
     for wf in candidates:
         try:
             r = await gh.rest.actions.async_list_workflow_runs(
-                sub.owner, sub.repo, wf, branch=branch, per_page=1)
+                sub.owner, sub.repo, wf, branch=branch, per_page=10)
         except RequestFailed as e:
             if _missing(e): continue
             raise
         runs = r.parsed_data.workflow_runs
         if runs:
-            run = runs[0]
+            run = newest_run(runs)
             # conclusion is None while a run is still going, status covers that case
             return {"state": run.conclusion or run.status, "sha": run.head_sha, "url": run.html_url}
     return None

{nbdevauto-0.3.67 → nbdevauto-0.3.69/nbdevAuto.egg-info}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nbdevAuto
-Version: 0.3.67
+Version: 0.3.69
 Summary: automating nbdev
 Author-email: Benedict Thekkel <bthekkel1@gmail.com>
 License-Expression: Apache-2.0
@@ -70,26 +70,28 @@ from nbdevAuto.pdf import PDFreader
 | Page | Covers |
 |----|----|
 | [Functions](00_Functions.ipynb) | Dataset and image helpers: reading a list out of a text file, downloading single images or whole search-driven datasets, verifying and resizing what came back, building the folder layout a classifier expects, running a fastai learner over one image, Kaggle competition and dataset shortcuts, and [`graph`](https://bthek1.github.io/nbdevAuto/functions.html#graph), a `graphviz.Digraph` subclass preloaded with a rounded, filled style |
-| [Automate](01_Automate.ipynb) | The command line surface: the prep/commit/push pipeline, the GitHub and PyPI release halves, and the help output that lists them all |
+| [Automate](01_Automate.ipynb) | The command line surface: the prep/commit/push pipeline, the GitHub and PyPI release halves, the help output that lists them all, and the one-line-per-stage console grid every command reports through |
 | [PDF Reader](02_PDF_reader.ipynb) | [`PDFreader`](https://bthek1.github.io/nbdevAuto/pdf_reader.html#pdfreader), a class that converts a PDF through `pdf2image` and renders page ranges inline when you slice it (`pdf[0:5]`) |
-| [GitHub](03_GitHub.ipynb) | [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus): reading `.gitmodules`, resolving a token, and asking the GitHub API about every submodule at once - CI runs, Pages deploys, Pages builds, remote `main` shas - plus the `--report` and `--audit` views and the exit codes that keep “absent” apart from “cannot ask” |
+| [GitHub](03_GitHub.ipynb) | [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus): reading `.gitmodules`, resolving a token, and asking the GitHub API about every submodule at once - CI runs, Pages deploys, Pages builds, remote `main` shas - plus the `--report` and `--audit` views, the exit codes that keep “absent” apart from “cannot ask”, and `newest_run`, which picks a run by `run_number` because the API’s page order is not a contract |
+| [Fleet](04_Fleet.ipynb) | [`fleet`](https://bthek1.github.io/nbdevAuto/fleet.html#fleet): running one command across every submodule of a superproject. A walker that reports only what did work and counts the rest, plus the verbs built on it - upload, push, copy, status, update and sync |
 ------------------------------------------------------------------------
 ## The Command Line Surface
-Installing the package puts these on your `PATH`. Most are ordinary functions in [Automate](01_Automate.ipynb), exposed as scripts through `[project.scripts]`; [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus) comes from [GitHub](03_GitHub.ipynb).
+Installing the package puts these on your `PATH`. Most are ordinary functions in [Automate](01_Automate.ipynb), exposed as scripts through `[project.scripts]`; [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus) comes from [GitHub](03_GitHub.ipynb) and [`fleet`](https://bthek1.github.io/nbdevAuto/fleet.html#fleet) from [Fleet](04_Fleet.ipynb).
 | Command | Does |
 |----|----|
 | [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) | Bump the version, then export, test and clean the notebooks, refreshing `_quarto.yml` and the README |
-| [`gacp`](https://bthek1.github.io/nbdevAuto/automate.html#gacp) | git add, commit, and push. Without `-m` the commit message is the status output |
+| [`gacp`](https://bthek1.github.io/nbdevAuto/automate.html#gacp) | git add, commit, and push. Without `-m` the message is built from the staged paths |
 | [`status`](https://bthek1.github.io/nbdevAuto/automate.html#status) | Show the working tree state |
 | [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) | [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) then [`gacp`](https://bthek1.github.io/nbdevAuto/automate.html#gacp), the one you actually type |
 | `gitrelease` | Bump the **minor** version, then tag and create a GitHub release |
 | `piprelease` | Build the sdist and wheel, then upload to PyPI with twine |
 | [`release`](https://bthek1.github.io/nbdevAuto/automate.html#release) | `gitrelease` then `piprelease` |
 | [`ghstatus`](https://bthek1.github.io/nbdevAuto/github.html#ghstatus) | Remote status for every submodule of an nbdev superproject, from the GitHub API. `--report` for the sync view, `--audit` to check `.gitmodules` against the repos the account owns, `--json` for machine output |
+| [`fleet`](https://bthek1.github.io/nbdevAuto/fleet.html#fleet) | Run one command across every submodule: `fleet upload|push|copy|status|update|sync`. Every verb takes `--help`, and the destructive ones take `--dry-run` |
 | `h` | Print the list of available commands |
 Both [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) and [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) take `-p` to choose which version part to increment; it defaults to 2, the patch, so every [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) ships a new version.
@@ -100,6 +102,25 @@ Both [`prep`](https://bthek1.github.io/nbdevAuto/automate.html#prep) and [`uploa
 ------------------------------------------------------------------------
+## The Output Contract
+Every command reports through one grid, defined in [Automate](01_Automate.ipynb) and reused by [Fleet](04_Fleet.ipynb). It exists because these commands run 19 times in a row, so anything that costs three lines per stage costs sixty over a fleet.
+    1/6  bump version (part 2)  OK       75ms  0.3.67 -> 0.3.68
+    2/6  nbdev_export           OK      129ms
+    3/6  nbdev_test             OK       1.5s  6 notebooks, slowest 01_Automate.ipynb 1.0s
+Four rules hold it together, and a change to any stage has to keep them:
+- **One stage, one line, inside 88 columns.** The columns are fixed: `n/total` (5), label (22), outcome (4), duration (7), detail (the rest). A unit test renders real stages through a console pinned to that width and asserts every line fits.
+- **A summariser returns short strings, not a transcript.** [`_test_summary`](https://bthek1.github.io/nbdevAuto/automate.html#_test_summary) turns a line per notebook into `6 notebooks, slowest X 1.0s`; [`_push_summary`](https://bthek1.github.io/nbdevAuto/automate.html#_push_summary) turns nine lines of git progress into a sha range and a size. Anything too long for the detail column moves to an indented continuation line, so a verbose summariser degrades the layout rather than breaking it.
+- **A stage that shells out must capture at the file-descriptor level.** `redirect_stdout` only rebinds Python’s `sys.stdout`, so a child process writing to fd 1 walks straight past it - which is how `nbdev_readme` used to spill sixteen lines of pandoc metadata into the middle of a run. [`_quiet`](https://bthek1.github.io/nbdevAuto/automate.html#_quiet) swaps fds 1 and 2 for a temp file as well and merges both captures.
+- **A green OK has to mean something.** [`_run`](https://bthek1.github.io/nbdevAuto/automate.html#_run) raises on a non-zero exit rather than returning a code nobody reads, and the failure prints the command’s own output. Before that, a failed `git push` still reported `OK`.
+On a terminal the label is written first without a newline, so a slow stage is visible while it runs, then rewritten in place. Piped output skips that entirely, because a carriage return in a log file is just noise.
+------------------------------------------------------------------------
 ## Where It Is Used
 The parent Knowledge repo’s `justfile` calls [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) once per submodule. `just upload` runs it only where the working tree is dirty, `just full_upload` runs it everywhere. That is the main consumer, so a change to `automate.py` affects the publish path for every site in the collection.
@@ -116,9 +137,10 @@ Because [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) bump
 ## Not Covered Yet
-- **No test notebook for the helpers.** `03_GitHub.ipynb` carries unit tests for its pure functions, but the dataset and image helpers are exercised only by being used, so a broken one surfaces in a downstream repo rather than here.
+- **No tests for the helpers.** `01_Automate.ipynb`, `03_GitHub.ipynb` and `04_Fleet.ipynb` all carry unit tests for their pure functions - the fleet ones against a throwaway superproject of real git repos - but the dataset and image helpers in `00_Functions.ipynb` are exercised only by being used, so a broken one surfaces in a downstream repo rather than here.
 - **Undeclared dependencies.** `pyproject.toml` declares `graphviz` and `fastcore`, plus `githubkit` behind the `gh` extra. The helpers additionally import `fastai`, `fastbook`, `fastdownload`, `PIL`, `matplotlib`, `tqdm`, `pdf2image` (with poppler behind it), `nbdev` and `kaggle` (which also needs its credentials). All of those are imported lazily inside the function that needs them, so installing the package and running the console scripts still works - only the specific helper you call fails. Install them yourself.
 - **`core.py` is an empty nbdev stub** (a single `foo`) left over from `00_core.ipynb`, which no longer exists.
+- **`CHANGELOG.md` is still the nbdev stub** (`Version 1.0.0 - Initial release`) while the package is past 0.3.68. Nothing generates it, and [`upload`](https://bthek1.github.io/nbdevAuto/automate.html#upload) bumps the patch on every push, so it would need writing by hand or dropping.
 - The docstrings are one-liners, so the rendered API pages are thin. The notebooks carry the real explanation.
 ------------------------------------------------------------------------