[pre-commit.ci] auto fixes from pre-commit.com hooks

pre-commit-ci[bot] · pre-commit-ci[bot] · commit e4441290865c · 2026-05-22T21:14:06.000Z
for more information, see https://pre-commit.ci
diff --git a/papermill/cli.py b/papermill/cli.py
@@ -271,7 +271,9 @@ def papermill(
 @click.command('profile', context_settings=dict(help_option_names=['-h', '--help']))
 @click.argument('notebook_path')
 @click.option(
-    '--output', '-o', default=None,
+    '--output',
+    '-o',
+    default=None,
     help='Path to write profile JSON (default: <notebook>.profile.json).',
 )
 def papermill_profile(notebook_path, output):
@@ -296,10 +298,7 @@ def papermill_profile(notebook_path, output):
 
     if profile.get('bottleneck'):
         b = profile['bottleneck']
-        click.echo(
-            f"Bottleneck: [{b['cell_index']}] in «{b['section']}» "
-            f"— {b['duration_s']}s ({b['pct_of_total']}%)"
-        )
+        click.echo(f"Bottleneck: [{b['cell_index']}] in «{b['section']}» — {b['duration_s']}s ({b['pct_of_total']}%)")
 
     click.echo("\nSections:")
     for s in profile['sections']:
diff --git a/papermill/engines.py b/papermill/engines.py
@@ -96,8 +96,9 @@ class NotebookExecutionManager:
     COMPLETED = "completed"
     FAILED = "failed"
 
-    def __init__(self, nb, output_path=None, log_output=False, progress_bar=True, autosave_cell_every=30,
-                 live_display=None):
+    def __init__(
+        self, nb, output_path=None, log_output=False, progress_bar=True, autosave_cell_every=30, live_display=None
+    ):
         self.nb = nb
         self.output_path = output_path
         self.log_output = log_output
diff --git a/papermill/execute.py b/papermill/execute.py
@@ -120,8 +120,10 @@ def execute_notebook(
             _live_display = None
             if live_tree:
                 from .live_tree import LiveTreeDisplay, is_available as _rich_ok
+
                 if _rich_ok():
                     import os
+
                     nb_name = os.path.basename(input_path) if isinstance(input_path, str) else "notebook.ipynb"
                     _live_display = LiveTreeDisplay(nb, nb_name)
                     progress_bar = False  # Rich tree replaces tqdm
diff --git a/papermill/live_tree.py b/papermill/live_tree.py
@@ -45,6 +45,7 @@ def is_available() -> bool:
     """Return True if the ``rich`` package is installed."""
     try:
         import rich  # noqa: F401
+
         return True
     except ImportError:
         return False
@@ -53,11 +54,11 @@ def is_available() -> bool:
 # ── Glyph / colour helpers ────────────────────────────────────────────────────
 
 _GLYPH = {
-    "pending":   ("·", "dim"),
-    "running":   ("⟳", "yellow bold"),
+    "pending": ("·", "dim"),
+    "running": ("⟳", "yellow bold"),
     "completed": ("✓", "green"),
-    "failed":    ("✗", "red bold"),
-    "skipped":   ("—", "dim"),
+    "failed": ("✗", "red bold"),
+    "skipped": ("—", "dim"),
 }
 
 
@@ -86,16 +87,13 @@ class LiveTreeDisplay:
     def __init__(self, nb: "nbformat.NotebookNode", nb_name: str, refresh_per_second: int = 4):
         if not is_available():
             raise ImportError(
-                "The 'rich' package is required for live tree display. "
-                "Install it with: pip install 'papermill[rich]'"
+                "The 'rich' package is required for live tree display. Install it with: pip install 'papermill[rich]'"
             )
         from rich.console import Console
         from rich.live import Live
 
         self._sections: list[SectionProfile] = build_sections(nb)
-        self._cell_map: dict[int, CellProfile] = {
-            cp.index: cp for sec in self._sections for cp in sec.cells
-        }
+        self._cell_map: dict[int, CellProfile] = {cp.index: cp for sec in self._sections for cp in sec.cells}
         self._nb_name = nb_name
         self._n_total = sum(1 for c in nb.cells if c.cell_type == "code")
         self._n_done = 0
@@ -111,10 +109,7 @@ def _build_tree(self):
         from rich.tree import Tree
 
         pct = 100 * self._n_done / self._n_total if self._n_total else 0
-        header = (
-            f"[bold]{self._nb_name}[/]  "
-            f"[dim]{self._n_done}/{self._n_total} cells  {pct:.0f}%[/]"
-        )
+        header = f"[bold]{self._nb_name}[/]  [dim]{self._n_done}/{self._n_total} cells  {pct:.0f}%[/]"
         root = Tree(header, guide_style="dim")
         level_nodes: dict = {0: root}
 
@@ -125,10 +120,14 @@ def _build_tree(self):
             code_cells = [c for c in sec.cells if c.cell_type == "code"]
             sec_status = sec.status
             is_running = sec_status == "running"
-            live_start = next(
-                (c._live_start for c in code_cells if getattr(c, "_live_start", None) and c.status == "running"),
-                None,
-            ) if is_running else None
+            live_start = (
+                next(
+                    (c._live_start for c in code_cells if getattr(c, "_live_start", None) and c.status == "running"),
+                    None,
+                )
+                if is_running
+                else None
+            )
 
             glyph_ch, glyph_style = _GLYPH.get(sec_status, ("?", "dim"))
             glyph = Text(glyph_ch, style=glyph_style)
@@ -163,6 +162,7 @@ def _build_tree(self):
     @staticmethod
     def _dur_text(dur, running: bool = False, live_start=None):
         from rich.text import Text
+
         if running and live_start is not None:
             elapsed = time.monotonic() - live_start
             return Text(f"{elapsed:.1f}s…", style="yellow")
diff --git a/papermill/profile.py b/papermill/profile.py
@@ -132,7 +132,7 @@ def to_dict(self) -> dict:
 class SectionProfile:
     """A section of cells bounded by a markdown heading."""
 
-    title: str     # original markdown heading text
+    title: str  # original markdown heading text
     level: int
     number: str = ""  # e.g. "1", "1.2", "1.2.3"
     cells: list = field(default_factory=list)
@@ -331,9 +331,7 @@ def build_profile(notebook_path: str, nb: nbformat.NotebookNode) -> dict:
     n_errors = sum(1 for c in all_code if c.exception)
 
     def _label(idx: int) -> str:
-        return next(
-            (s.display_label for s in sections if any(x.index == idx for x in s.cells)), "?"
-        )
+        return next((s.display_label for s in sections if any(x.index == idx for x in s.cells)), "?")
 
     slowest = [{**c.to_dict(), "section": _label(c.index)} for c in sorted_dur[:5]]
 
diff --git a/papermill/tests/test_profile.py b/papermill/tests/test_profile.py
@@ -15,6 +15,7 @@
 
 # ── Fixtures ──────────────────────────────────────────────────────────────────
 
+
 def _make_nb(cells):
     """Build a minimal NotebookNode from a list of (type, source, pm_meta) tuples."""
     nb = nbformat.v4.new_notebook()
@@ -25,8 +26,11 @@ def _make_nb(cells):
         else:
             cell = nbformat.v4.new_code_cell(source)
             cell.metadata["papermill"] = pm_meta or {
-                "start_time": None, "end_time": None,
-                "duration": None, "status": "pending", "exception": False,
+                "start_time": None,
+                "end_time": None,
+                "duration": None,
+                "status": "pending",
+                "exception": False,
             }
         nb.cells.append(cell)
     return nb
@@ -44,6 +48,7 @@ def _executed_cell_meta(duration, status="completed", exception=False):
 
 # ── build_sections ────────────────────────────────────────────────────────────
 
+
 class TestBuildSections:
     def test_no_headings_creates_preamble(self):
         nb = _make_nb([("code", "x = 1", None), ("code", "y = 2", None)])
@@ -54,54 +59,75 @@ def test_no_headings_creates_preamble(self):
         assert len(sections[0].cells) == 2
 
     def test_single_heading(self):
-        nb = _make_nb([
-            ("markdown", "# Data Loading", None),
-            ("code", "import pandas", None),
-        ])
+        nb = _make_nb(
+            [
+                ("markdown", "# Data Loading", None),
+                ("code", "import pandas", None),
+            ]
+        )
         sections = build_sections(nb)
         assert len(sections) == 1
         assert sections[0].number == "1"
         assert sections[0].display_label == "Section 1"
 
     def test_sequential_numbering(self):
-        nb = _make_nb([
-            ("markdown", "# First", None), ("code", "a=1", None),
-            ("markdown", "# Second", None), ("code", "b=2", None),
-            ("markdown", "# Third", None), ("code", "c=3", None),
-        ])
+        nb = _make_nb(
+            [
+                ("markdown", "# First", None),
+                ("code", "a=1", None),
+                ("markdown", "# Second", None),
+                ("code", "b=2", None),
+                ("markdown", "# Third", None),
+                ("code", "c=3", None),
+            ]
+        )
         sections = build_sections(nb)
         assert [s.number for s in sections] == ["1", "2", "3"]
         assert [s.display_label for s in sections] == ["Section 1", "Section 2", "Section 3"]
 
     def test_nested_sub_sections(self):
-        nb = _make_nb([
-            ("markdown", "# Analysis", None), ("code", "x=1", None),
-            ("markdown", "## Cleaning", None), ("code", "y=2", None),
-            ("markdown", "## Feature Engineering", None), ("code", "z=3", None),
-            ("markdown", "# Results", None), ("code", "w=4", None),
-        ])
+        nb = _make_nb(
+            [
+                ("markdown", "# Analysis", None),
+                ("code", "x=1", None),
+                ("markdown", "## Cleaning", None),
+                ("code", "y=2", None),
+                ("markdown", "## Feature Engineering", None),
+                ("code", "z=3", None),
+                ("markdown", "# Results", None),
+                ("code", "w=4", None),
+            ]
+        )
         sections = build_sections(nb)
         labels = [s.display_label for s in sections]
         assert labels == ["Section 1", "Sub-section 1.1", "Sub-section 1.2", "Section 2"]
 
     def test_sub_section_counter_resets_across_top_sections(self):
-        nb = _make_nb([
-            ("markdown", "# A", None), ("code", "a=1", None),
-            ("markdown", "## A1", None), ("code", "b=2", None),
-            ("markdown", "# B", None), ("code", "c=3", None),
-            ("markdown", "## B1", None), ("code", "d=4", None),
-        ])
+        nb = _make_nb(
+            [
+                ("markdown", "# A", None),
+                ("code", "a=1", None),
+                ("markdown", "## A1", None),
+                ("code", "b=2", None),
+                ("markdown", "# B", None),
+                ("code", "c=3", None),
+                ("markdown", "## B1", None),
+                ("code", "d=4", None),
+            ]
+        )
         sections = build_sections(nb)
         numbers = [s.number for s in sections]
         # After # B the sub-counter resets, so ## B1 becomes 2.1 not 1.2
         assert numbers == ["1", "1.1", "2", "2.1"]
 
     def test_heading_cells_not_added_to_cell_list(self):
-        nb = _make_nb([
-            ("markdown", "# Title", None),
-            ("markdown", "Some prose (no heading)", None),
-            ("code", "x=1", None),
-        ])
+        nb = _make_nb(
+            [
+                ("markdown", "# Title", None),
+                ("markdown", "Some prose (no heading)", None),
+                ("code", "x=1", None),
+            ]
+        )
         sections = build_sections(nb)
         assert len(sections) == 1
         # Only the prose markdown + code cell should be in cells
@@ -110,6 +136,7 @@ def test_heading_cells_not_added_to_cell_list(self):
 
 # ── SectionProfile ────────────────────────────────────────────────────────────
 
+
 class TestSectionProfile:
     def test_display_label_preamble(self):
         s = SectionProfile(title="[preamble]", level=0, number="")
@@ -149,16 +176,19 @@ def test_to_dict_contains_label_and_title(self):
 
 # ── build_profile ─────────────────────────────────────────────────────────────
 
+
 class TestBuildProfile:
     def _make_executed_nb(self):
-        nb = _make_nb([
-            ("markdown", "# Imports", None),
-            ("code", "import numpy as np", _executed_cell_meta(0.1)),
-            ("markdown", "## Heavy computation", None),
-            ("code", "result = np.sum(range(1000))", _executed_cell_meta(5.0)),
-            ("markdown", "# Results", None),
-            ("code", "print(result)", _executed_cell_meta(0.05)),
-        ])
+        nb = _make_nb(
+            [
+                ("markdown", "# Imports", None),
+                ("code", "import numpy as np", _executed_cell_meta(0.1)),
+                ("markdown", "## Heavy computation", None),
+                ("code", "result = np.sum(range(1000))", _executed_cell_meta(5.0)),
+                ("markdown", "# Results", None),
+                ("code", "print(result)", _executed_cell_meta(0.05)),
+            ]
+        )
         nb.metadata["papermill"] = {
             "start_time": "2026-01-01T00:00:00+00:00",
             "end_time": "2026-01-01T00:00:06+00:00",
@@ -203,6 +233,7 @@ def test_n_errors_counts_exceptions(self):
 
 # ── profile_notebook ──────────────────────────────────────────────────────────
 
+
 class TestProfileNotebook:
     def test_returns_dict(self, tmp_path):
         nb = nbformat.v4.new_notebook()
@@ -236,7 +267,9 @@ def test_writes_json_file(self, tmp_path):
 
 # ── live_tree availability guard ──────────────────────────────────────────────
 
+
 class TestLiveTreeAvailability:
     def test_is_available_returns_bool(self):
         from papermill.live_tree import is_available
+
         assert isinstance(is_available(), bool)
diff --git a/pyproject.toml b/pyproject.toml
@@ -108,7 +108,7 @@ optional-dependencies.docs = [
 optional-dependencies.gcs = [ "gcsfs>=0.2" ]
 optional-dependencies.github = [ "pygithub>=1.55" ]
 optional-dependencies.hdfs = [ "pyarrow>=2" ]
-optional-dependencies.rich = [ "rich>=13.0" ]
+optional-dependencies.rich = [ "rich>=13" ]
 optional-dependencies.s3 = [ "boto3" ]
 optional-dependencies.test = [
   "attrs>=17.4",
