Jupyter notebook support

[davidagold]

What

This branch contains a sketch of Jupyter notebook support for Zed. Given that there are already efforts underway to develop such functionality, I would be content for the upshot of the present implementation to be my familiarizing myself with the codebase and having some fun. However, if there is desire to incorporate any part of this work, please let me know! I would be happy to continue developing it.

(As an aside, the top-line LOC changed figures are somewhat misleading, as ~2K lines are attributable to lock files.)

The code is organized as follows:

• crates/notebook/src
  • actions.rs -- Notebook actions
  • cell.rs -- Encapsulation of notebook cell functionality, primarily in the Cell and Cells structs. The former represents an individual cell; the latter represents an ordered collection of cells and contains functionality for managing the cells' relations to the MultiBuffer through which the cell contents are exposed via an Editor.
  • chat.rs -- Chat functionality that can be accessed from within the notebook.
  • common.rs -- Common utilities
  • editor.rs -- Provides NotebookEditor, a wrapper around a View<Editor> through which a user can interact with the notebook (e.g. by inserting new cells or running the presently focused cell/selection).
  • jupyter/ -- While still aspirational, my intention is for this directory to contain Jupyter-specific functionality and to make the core Notebook, Cells, NotebookEditor constructs sufficiently generic so as to support other kinds of interactive development. The present implementation uses pyo3 to integrate a Python-based kernel connection construct that uses the jupyter_client Python package directly into Zed, and the jupyter/ directory contains the relevant code.
    • jupyter/connection.py -- Provides the KernelConnection Python construct, which exposes jupyter_client functionality for use in the JupyterKernelClient Rust struct.
    • jupyter/message.py -- Provides Pydantic models for Jupyter messages.
    • jupyter/message.rs -- Provides Rust models for Jupyter messages.
    • jupyter/python.rs -- Provides utilities for integrating asynchronous Python applications in Zed.
  • kernel.rs -- Provides the JupyterKernelClient through which the NotebookEditor interacts with the kernel. Upon initialization, the JupyterKernelClient launches a background task that listens for commands from the client and messages from the kernel via the KernelConnection. When the kernel publishes a message, a Python forwarder sends the message to the background task via a channel, and the task in turn emits an event containing the message. The NotebookEditor in turn subscribes to the client and updates the notebook accordingly. (Arguably this should be in jupyter/.)
  • notebook.rs -- Provides the Notebook container for Cells, the handle for the client, and methods for deserialization of .ipynb files.

The notebook view itself just uses the present Editor over a MultiBuffer, where each cell is represented as excerpts spanning its respective source and output Buffers. I'm sure it would be preferable to tailor this view, but it served rather well for a prototype. I would be curious to see whether a new EditorMode variant, e.g. EditorMode::Notebook would be a good means of including such customizations.

The present implementation only supports plaintext output.

notebook.mov