Jupyter for Visual Studio Code

The Jupyter extension provides a rich notebook experience integrated with VS Code's core editor features:

• IntelliSense: Provides auto-completion, code navigation, and syntax checking.
• Notebook UI: Built on VS Code's native notebook API, supporting features like hot exit, find & replace, and code folding.
• Editor Integration: Supports standard editor extensions like VIM, bracket colorization, and linters within cells.
• Output Rendering: Includes built-in renderers for common MIME types (latex, plotly, vega, etc.) and supports custom installable renderers via the marketplace.
• Notebook Diffing: Includes a specialized diff tool for comparing code cells, outputs, and metadata.

To display ipywidgets in a context that is not a standard Jupyter Notebook, the following three components are required:

1. requirejs: For module loading.
2. HTML Manager: To manage the widget lifecycle and rendering.
3. Live Kernel: The widget manager must plug directly into kernel messages to read/write and build data for display.

Note that because the kernel connection is only available in the backend (extension code), a proxy kernel connection must be implemented in the frontend (React layer) to bridge the HTML manager with the actual kernel.

Since the HTML manager cannot access the backend kernel connection directly, the extension implements a proxy kernel connection in the React layer. This architecture uses a postoffice to facilitate communication:

• Extension to React Layer: Kernel messages from the extension are sent to the React layer via the postoffice.
• React Layer to Actual Kernel: Messages sent from the HTML manager via the kernel are routed back to the actual kernel via the postoffice.

The implementation involves complex message processing logic, borrowing heavily from @jupyterlab/services (specifically comm.js, default.js, future.js, kernel.js, and manager.js) to ensure kernel messages are correctly sequenced and massaged.

To use Jupyter notebooks with Python in VS Code, follow these steps:

1. Install VS Code.
2. Set up a Python environment: Install Anaconda, Miniconda, or another Python environment that has the jupyter package installed.
3. Install Extensions: Install both the Jupyter Extension and the Python Extension.
4. Create a Notebook: Open the Command Palette (Ctrl+Shift+P) and select Jupyter: Create New Jupyter Notebook.
5. Select a Kernel: Click the kernel picker in the top right of the notebook or run the Notebook: Select Notebook Kernel command to choose your Python environment.

To report bugs or request new features for the Jupyter extension, use GitHub Issues. It is recommended to search existing issues before filing a new one to prevent duplicates.

For general questions, help, or discussions regarding the project, use the GitHub Discussions feature.

You can measure the execution time of Python statements or expressions using the timeit magic command. It is available in two modes:

• Line mode (%timeit): Used to time a single-line statement. Multiple statements can be chained using semicolons.
• Cell mode (%%timeit): Used to time the entire body of a cell. The first line of the cell is treated as setup_code (executed but not timed), and the subsequent lines are the code to be timed. The timed body has access to variables defined in the setup code.

If you are using the Anaconda distribution, follow these steps to install and configure Jupyter:

1. Start your Anaconda environment.
2. Run the command conda install jupyter.
3. Restart VS Code.
4. Use the Python selector in VS Code to pick the Conda version of Python.

To remove a package from the search list, use the detach() function.

Detaching by Name

If you attached a package normally, you can detach it using its position in the search list:

detach("package:splines")

Detaching from a Character Vector

If the package name is in a variable, you must find its position in the search list using match():

pkg <- "splines"
detach(pos = match(paste("package", pkg, sep = ":"), search()))

Reloading Packages

library() and require() do not reload a namespace that is already loaded. To reload a package, you must first call detach(unload = TRUE) or unloadNamespace.

# If the package name is in a character vector, use
pkg <- "splines"
library(pkg, character.only = TRUE)
detach(pos = match(paste("package", pkg, sep = ":"), search()))