Method mutate_graph

marimo/_runtime/runtime.py:1064–1301

Add and remove cells to/from the graph. This method adds the cells in `execution_requests` to the kernel's graph (deleting old versions of these cells, if any), and removes the cells in `deletion_requests` from the kernel's graph. The mutations that this method make

(
        self,
        execution_requests: Sequence[ExecuteCellCommand],
        deletion_requests: Sequence[DeleteCellCommand],
        cells_starting_stale: set[CellId_t] | None = None,
    )

        return self._deactivate_cell(cell_id)

    def mutate_graph(
        self,
        execution_requests: Sequence[ExecuteCellCommand],
        deletion_requests: Sequence[DeleteCellCommand],
        cells_starting_stale: set[CellId_t] | None = None,
    ) -> set[CellId_t]:
        """Add and remove cells to/from the graph.

        This method adds the cells in `execution_requests` to the kernel's
        graph (deleting old versions of these cells, if any), and removes the
        cells in `deletion_requests` from the kernel's graph.

        The mutations that this method makes to the graph renders the
        kernel inconsistent (stale).

        This method does not register errors for cells that were previously
        valid and are not descendants of any of the newly registered cells.
        This is important for multiple definition errors, since a user may
        absent-mindedly redefine an existing name when creating a new cell:
        such a mistake shouldn't invalidate the program state.

        Returns:
        - set of cells that must be run to return kernel to consistent state
        """
        LOGGER.debug("Mutating graph.")
        LOGGER.debug("Current set of errors: %s", self.errors)
        # Invalidate the cached notebook→source position map so that
        # recompiled cells pick up the current file contents. This
        # matters for debugpy (edit mode) and `marimo run --watch`
        # where cells are recompiled after the file changes on disk.
        _build_source_position_map.cache_clear()
        cells_before_mutation = set(self.graph.cells.keys())
        cells_with_errors_before_mutation = set(self.errors.keys())
        cells_starting_stale = (
            set() if cells_starting_stale is None else cells_starting_stale
        )

        # The set of cells that were successfully registered
        registered_cell_ids: set[CellId_t] = set()

        # The set of cells that need to be re-run due to cells being
        # deleted/re-registered.
        cells_that_were_children_of_mutated_cells: set[CellId_t] = set()

        # Cells that were unable to be added to the graph due to syntax errors
        syntax_errors: dict[CellId_t, Error] = {}

        # Register and delete cells
        for er in execution_requests:
            old_children, error = self._maybe_register_cell(
                er.cell_id, er.code, stale=er.cell_id in cells_starting_stale
            )
            cells_that_were_children_of_mutated_cells |= old_children
            if error is None:
                registered_cell_ids.add(er.cell_id)
            else:
                syntax_errors[er.cell_id] = error