fix: comment cleanup

Author: dmadisetti

marimo/_ast/cell.py

@@ -483,7 +483,8 @@ def _is_coroutine(self) -> bool:
         assert self._app is not None
         from marimo._runtime.runner import by_kwargs
 
-        # ``graph`` triggers _maybe_initialize on the underlying App.
+        # Currently expensive since `graph` triggers _maybe_initialize on the
+        # underlying App.
         self._is_coro_cached: bool = by_kwargs.is_coroutine(
             self._app.graph, self._cell.cell_id
         )

marimo/_runtime/app/script_runner.py

@@ -153,22 +153,14 @@ def _handle_run_result(
         result: RunResult,
         outputs: dict[CellId_t, Any],
     ) -> None:
-        """Classify the Evaluator's RunResult; record output, cancel, or raise.
-
-        Aligns MarimoStopError handling with the kernel classifier: the
-        stop's output is recorded for the cell and descendants are
-        cancelled, instead of silently swallowing both.
-        """
+        """Classify the Evaluator's RunResult; record output/cancel/raise."""
         exc = result.exception
         if exc is None:
             outputs[cid] = result.output
             return
         if not isinstance(exc, BaseException):
-            # An Error-shape payload (e.g. ``MarimoStrictExecutionError``)
-            # from a lifecycle ``Skip(result=...)``. Script mode runs with
-            # no lifecycles today, so this is unreachable in practice;
-            # treat defensively by recording the output and cancelling
-            # descendants.
+            # Defensive check descendants, since all exceptions are expected to
+            # be wrapper..
             outputs[cid] = result.output
             self._scheduler.cancel(cid)
             return

marimo/_runtime/executor/evaluator.py

@@ -49,7 +49,7 @@ async def evaluate(
             result: RunResult = RunResult(output=None, exception=body_exc)
         elif skip is not None:
             # Lifecycle short-circuited — pass its full RunResult through
-            # so ``accumulated_output`` and any other field survive.
+            # so `accumulated_output` and any other field survive.
             result = (
                 skip.result
                 if skip.result is not None
@@ -67,7 +67,7 @@ async def evaluate(
     def evaluate_sync(
         self, cell: CellImpl, glbls: MutableGlobals
     ) -> RunResult:
-        """Sync mirror of ``evaluate`` — for callers without an event loop."""
+        """Sync mirror of `evaluate` — for callers without an event loop."""
         completed, skip, body_exc = self._setup_chain(cell, glbls)
 
         if body_exc is not None:
@@ -90,12 +90,7 @@ def evaluate_sync(
     async def evaluate_interruptible(
         self, cell: CellImpl, glbls: MutableGlobals
     ) -> RunResult:
-        """Await ``evaluate`` with SIGINT capture for coroutine cells.
-
-        SIGINT during an awaited coroutine raises in the event loop, not
-        in the user's coroutine. Wrap the future so SIGINT cancels it.
-        Sync cells and non-main-thread callers just await ``evaluate``.
-        """
+        """Await `evaluate` with SIGINT capture for coroutine cells."""
         if not cell.is_coroutine():
             return await self.evaluate(cell, glbls)
         future = asyncio.ensure_future(self.evaluate(cell, glbls))
@@ -190,12 +185,7 @@ def resolve_executor() -> Executor:
 # https://github.com/ipython/ipykernel/blob/eddd3e666a82ebec287168b0da7cfa03639a3772/ipykernel/ipkernel.py#L312
 @contextlib.contextmanager
 def _cancel_on_sigint(future: asyncio.Future[Any]) -> Iterator[None]:
-    """Cancel ``future`` if a SIGINT arrives during the ``with`` block.
-
-    SIGINT raises in the event loop when running async code, but we want
-    it to halt the coroutine. Ideally it would raise ``KeyboardInterrupt``,
-    but this turns it into a ``CancelledError``.
-    """
+    """Cancel `future` if a SIGINT arrives during evaluation."""
     sigint_future: asyncio.Future[int] = asyncio.Future()
 
     def cancel_unless_done(f: asyncio.Future[Any], _: Any) -> None:
@@ -211,10 +201,10 @@ def cancel_unless_done(f: asyncio.Future[Any], _: Any) -> None:
     )
 
     # Capture the previously-installed SIGINT handler *before* we install
-    # ours so ``handle_sigint`` can invoke it for its side effects
+    # ours so `handle_sigint` can invoke it for its side effects
     # (kernel broadcast, duckdb interrupt). For async cells the actual
     # halt comes from cancelling the future, not from a raised
-    # ``MarimoInterrupt`` — so we swallow that here.
+    # `MarimoInterrupt` — so we swallow that here.
     prior_sigint = signal.getsignal(signal.SIGINT)
 
     def handle_sigint(signum: int, frame: Any) -> None:

marimo/_runtime/executor/executor.py

@@ -15,12 +15,10 @@
 
 
 def _strip_frame(e: BaseException, count: int = 1) -> None:
-    """Drop the top ``count`` frames from ``e.__traceback__``.
+    """Drop the top `count` frames from `e.__traceback__`.
 
-    Used by executors to elide their own frames so user-facing
-    tracebacks start at user code. Stops early if the traceback runs
-    out — never strips the last frame, so we don't lose the only
-    frame we have.
+    Stops early if the traceback runs out — never strips the last
+    frame, so we don't lose the only frame we have.
     """
     tb = e.__traceback__
     for _ in range(count):
@@ -58,9 +56,7 @@ def execute_cell(self, cell: CellImpl, glbls: MutableGlobals) -> Any:
             exec(cell.body, glbls)
             return eval(cell.last_expr, glbls)
         except asyncio.CancelledError:
-            # Cancellation is control flow, not user error — let the
-            # caller see the bare exception so the runner's interrupt
-            # path fires.
+            # Cancellation is control flow, not user error — surface bare.
             raise
         except BaseException as e:
             # Strip our own frame so user-facing tracebacks start at user code.

marimo/_runtime/runner/by_kwargs.py

@@ -1,9 +1,9 @@
 # Copyright 2026 Marimo. All rights reserved.
-"""Run individual cells in a graph with caller-provided ref substitution.
+"""Lightweight runner functions for use in direct cell evaluation or testing.
 
-Backs the ``Cell.run(**kwargs)`` public API. Walks the cell's ancestor
-closure (minus any ancestor whose defs the caller substituted via
-kwargs), runs them with a fresh globals dict, then runs the target cell.
+Walks the cell's ancestor closure (minus any ancestor whose defs the
+caller substituted via kwargs), runs them with a fresh globals dict,
+then runs the target cell.
 """
 
 from __future__ import annotations
@@ -76,17 +76,12 @@ def _get_ancestors(
 
 
 def _classify(result: RunResult) -> MarimoStopError | None:
-    """Inspect a RunResult; raise on real errors, return the stop on mo.stop.
-
-    ``MarimoStopError`` is control flow, not a user-facing error — by_kwargs
-    halts cleanly and surfaces the carried output in place of raising. Any
-    other exception is the user's and propagates.
-    """
+    """Inspect a RunResult; raise on real errors, return the stop on mo.stop."""
     exc = result.exception
     if exc is None:
         return None
     if isinstance(exc, MarimoStopError):
-        # Defensive: any caller bypassing ``MarimoRuntimeException``
+        # Defensive: any caller bypassing `MarimoRuntimeException`
         # wrapping (e.g. a custom Executor that raises directly) still
         # gets stop-control-flow handling.
         return exc
@@ -106,10 +101,7 @@ def is_coroutine(
 ) -> bool:
     """True if the cell or any of its unsubstituted ancestors is async.
 
-    Pass ``kwargs`` if you want substitutions taken into account — an
-    ancestor whose def is provided by the caller is omitted from the
-    ancestor closure, so a graph that *would* be async without the
-    substitution may be sync with it.
+    NB. Currently expensive due to calls on graph.
     """
     return graph.cells[cell_id].is_coroutine() or any(
         graph.cells[cid].is_coroutine()
@@ -160,7 +152,7 @@ def run_cell_sync(
     Substitutes kwargs as refs for the cell, omitting ancestors whose
     refs are substituted.
 
-    Raises ``RuntimeError`` if the cell or any of its unsubstituted
+    Raises `RuntimeError` if the cell or any of its unsubstituted
     ancestors are coroutine functions.
     """
     from marimo._runtime.dataflow import topological_sort

marimo/_types/globals.py

@@ -1,8 +1,8 @@
 # Copyright 2026 Marimo. All rights reserved.
 """Type aliases for cell globals dicts.
 
-``MutableGlobals`` is the concrete ``dict`` passed through ``exec`` /
-``eval``; ``Globals`` is the read-only view for consumers that only
+`MutableGlobals` is the concrete `dict` passed through `exec` /
+`eval`; `Globals` is the read-only view for consumers that only
 inspect the dict (e.g. collecting a cell's defs after execution).
 """
 

tests/_runtime/runner/test_cell_runner.py

@@ -286,9 +286,8 @@ async def test_runner_dispatches_to_registered_plugin_executor(
     exec_req: ExecReqProvider,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    """A factory registered against ``marimo.cell.executor`` is the one
-    the kernel ``Runner`` dispatches through — proves the plugin flow
-    works end-to-end, not just the registry in isolation."""
+    """A factory registered against `marimo.cell.executor` is the one
+    the kernel `Runner` dispatches through."""
     from typing import Any
 
     from marimo._runtime.executor.evaluator import _EXECUTOR_REGISTRY
@@ -319,8 +318,8 @@ def factory() -> _SentinelExecutor:
     k = execution_kernel
     await k.run([er := exec_req.get("'hello'; 123")])
 
-    # Fully isolate the registry: replace both ``_plugins`` and
-    # ``names`` so installed third-party entry points can't shadow the
+    # Fully isolate the registry: replace both `_plugins` and
+    # `names` so installed third-party entry points can't shadow the
     # sentinel. monkeypatch restores both on teardown.
     monkeypatch.setattr(_EXECUTOR_REGISTRY, "_plugins", {"sentinel": factory})
     monkeypatch.setattr(_EXECUTOR_REGISTRY, "names", lambda: ["sentinel"])
@@ -344,9 +343,9 @@ def factory() -> _SentinelExecutor:
 async def test_runner_interrupted_flag_flips_on_sync_marimo_interrupt(
     execution_kernel: Kernel, exec_req: ExecReqProvider
 ) -> None:
-    """Sync cell body raising ``MarimoInterrupt`` (== ``KeyboardInterrupt``)
-    surfaces as a bare ``MarimoInterrupt`` in the run result and flips
-    ``runner.interrupted``. Covers ``cell_runner.py:441-442``."""
+    """Sync cell body raising `MarimoInterrupt` (== `KeyboardInterrupt`)
+    surfaces as a bare `MarimoInterrupt` in the run result and flips
+    `runner.interrupted`."""
     k = execution_kernel
     await k.run([er := exec_req.get("raise KeyboardInterrupt")])
 
@@ -368,19 +367,16 @@ async def test_runner_interrupted_flag_flips_on_async_cell_cancellation(
     exec_req: ExecReqProvider,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    """An async cell cancelled mid-await flips ``runner.interrupted``.
-
-    After the production fix, ``CancelledError`` propagates unwrapped
-    from ``DefaultExecutor`` and arrives in the ``RunResult.exception``
-    as a bare ``asyncio.CancelledError``. ``_finalize_run_result``'s
-    bare-``CancelledError`` branch converts it to ``MarimoInterrupt``,
-    which ``run()`` recognises to flip the flag.
-
-    We simulate the post-fix evaluator output directly (a bare
-    ``CancelledError`` in the ``RunResult``) so this test is independent
-    of the executor's coroutine compilation; the executor-level
-    propagation is covered by
-    ``test_executor_async_cancellation_propagates_unwrapped``.
+    """An async cell cancelled mid-await flips `runner.interrupted`.
+
+    A bare `asyncio.CancelledError` arriving in `RunResult.exception` is
+    converted to `MarimoInterrupt` by the bare-`CancelledError` branch
+    of `_finalize_run_result`, which `run()` recognises to flip the
+    flag.
+
+    Simulates the evaluator output directly (a bare `CancelledError` in
+    the `RunResult`) so this test is independent of the executor's
+    coroutine compilation.
     """
     import asyncio