Magma is a NeoVim plugin for running code interactively with Jupyter.
- NeoVim 0.5+
- Python 3.8+
- Required Python packages:
pynvim
(for the Remote Plugin API)jupyter_client
(for interacting with Jupyter)ueberzug
(for displaying images. Not available on MacOS, but see #15 for alternatives)Pillow
(also for displaying images, should be installed withueberzug
)cairosvg
(for displaying SVG images)pnglatex
(for displaying TeX formulas)plotly
andkaleido
(for displaying Plotly figures)pyperclip
if you want to usemagma_copy_output
- For .NET (C#, F#)
dotnet tool install -g Microsoft.dotnet-interactive
dotnet interactive jupyter install
You can do a :checkhealth
to see if you are ready to go.
Note: Python packages which are used only for the display of some specific kind of output are only imported when that output actually appears.
Use your favourite package/plugin manager.
If you use packer.nvim
,
use { 'dccsillag/magma-nvim', run = ':UpdateRemotePlugins' }
If you use vim-plug
,
Plug 'dccsillag/magma-nvim', { 'do': ':UpdateRemotePlugins' }
Note that you will still need to configure keymappings -- see Keybindings.
If you want a quickstart, these are the author's suggestions of mappings and options (beware of potential conflicts of these mappings with your own!):
nnoremap <silent><expr> <LocalLeader>r :MagmaEvaluateOperator<CR>
nnoremap <silent> <LocalLeader>rr :MagmaEvaluateLine<CR>
xnoremap <silent> <LocalLeader>r :<C-u>MagmaEvaluateVisual<CR>
nnoremap <silent> <LocalLeader>rc :MagmaReevaluateCell<CR>
nnoremap <silent> <LocalLeader>rd :MagmaDelete<CR>
nnoremap <silent> <LocalLeader>ro :MagmaShowOutput<CR>
let g:magma_automatically_open_output = v:false
let g:magma_image_provider = "ueberzug"
Note: Key mappings are not defined by default because of potential conflicts -- the user should decide which keys they want to use (if at all).
Note: The options that are altered here don't have these as their default values in order to provide a simpler (albeit perhaps a bit more inconvenient) UI for someone who just added the plugin without properly reading the README.
To make initialisation of kernels easier, you can add these commands:
function MagmaInitPython()
vim.cmd[[
:MagmaInit python3
:MagmaEvaluateArgument a=5
]]
end
function MagmaInitCSharp()
vim.cmd[[
:MagmaInit .net-csharp
:MagmaEvaluateArgument Microsoft.DotNet.Interactive.Formatting.Formatter.SetPreferredMimeTypesFor(typeof(System.Object),"text/plain");
]]
end
function MagmaInitFSharp()
vim.cmd[[
:MagmaInit .net-fsharp
:MagmaEvaluateArgument Microsoft.DotNet.Interactive.Formatting.Formatter.SetPreferredMimeTypesFor(typeof<System.Object>,"text/plain")
]]
end
vim.cmd[[
:command MagmaInitPython lua MagmaInitPython()
:command MagmaInitCSharp lua MagmaInitCSharp()
:command MagmaInitFSharp lua MagmaInitFSharp()
]]
The plugin provides a bunch of commands to enable interaction. It is recommended to map most of them to keys, as explained in Keybindings. However, this section will refer to the commands by their names (so as to not depend on some specific mappings).
When you execute some code, it will create a cell. You can recognize a cell because it will be highlighted when your cursor is in it.
A cell is delimited using two extmarks (see :help api-extended-marks
), so it will adjust to you editing the text within it.
When your cursor is in a cell (i.e., you have an active cell), a floating window may be shown below the cell, reporting output. This is the display window, or output window. (To see more about whether a window is shown or not, see :MagmaShowOutput
and g:magma_automatically_open_output
). When you cursor is not in any cell, no cell is active.
Also, the active cell is searched for from newest to oldest. That means that you can have a cell within another cell, and if the one within is newer, then that one will be selected. (Same goes for merely overlapping cells).
The output window has a header, containing the execution count and execution state (i.e., whether the cell is waiting to be run, running, has finished successfully or has finished with an error). Below the header are shown the outputs.
Jupyter provides a rich set of outputs. To see what we can currently handle, see Output Chunks.
This command initializes a runtime for the current buffer.
It can take a single argument, the Jupyter kernel's name. For example,
:MagmaInit python3
will initialize the current buffer with a python3
kernel.
It can also be called with no arguments, as such:
:MagmaInit
This will prompt you for which kernel you want to launch (from the list of available kernels).
This command deinitializes the current buffer's runtime and magma instance.
:MagmaDeinit
Note You don't need to run this, as deinitialization will happen automatically upon closing Vim or the buffer being unloaded. This command exists in case you just want to make Magma stop running.
Evaluate the current line.
Example usage:
:MagmaEvaluateLine
Evaluate the selected text.
Example usage (after having selected some text):
:MagmaEvaluateVisual
Evaluate the text given by some operator.
This won't do much outside of an <expr>
mapping. Example usage:
nnoremap <expr> <LocalLeader>r nvim_exec('MagmaEvaluateOperator', v:true)
Upon using this mapping, you will enter operator mode, with which you will be able to select text you want to execute. You can, of course, hit ESC to cancel, as usual with operator mode.
Evaluate the text following this command. Could be used for some automation (e. g. run something on initialization of a kernel).
:MagmaEvaluateArgument a=5;
Reevaluate the currently selected cell.
:MagmaReevaluateCell
Delete the currently selected cell. (If there is no selected cell, do nothing.)
Example usage:
:MagmaDelete
This only makes sense when you have g:magma_automatically_open_output = v:false
. See Customization.
Running this command with some active cell will open the output window.
Example usage:
:MagmaShowOutput
Send a keyboard interrupt to the kernel. Interrupts the currently running cell and does nothing if not cell is running.
Example usage:
:MagmaInterrupt
Shuts down and restarts the current kernel.
Optionally deletes all output if used with a bang.
Example usage:
:MagmaRestart
Example usage (also deleting outputs):
:MagmaRestart!
Save the current cells and evaluated outputs into a JSON file, which can then be loaded back with :MagmaLoad
.
It has two forms; first, receiving a parameter, specifying where to save to:
:MagmaSave file_to_save.json
If that parameter is omitted, then one will be automatically generated using the g:magma_save_path
option.
:MagmaSave
Load the cells and evaluated outputs stored in a given JSON file, which should have been generated with :MagmaSave
.
Like MagmaSave
, It has two forms; first, receiving a parameter, specifying where to save to:
:MagmaLoad file_to_load.json
If that parameter is omitted, then one will be automatically generated using the g:magma_save_path
option.
Enter the output window, if it is currently open. You must call this as follows:
:noautocmd MagmaEnterOutput
This is escpecially useful when you have a long output (or errors) and wish to inspect it.
It is recommended to map all the evaluate commands to the same mapping (in different modes). For example, if we wanted to bind evaluation to <LocalLeader>r
:
nnoremap <expr><silent> <LocalLeader>r nvim_exec('MagmaEvaluateOperator', v:true)
nnoremap <silent> <LocalLeader>rr :MagmaEvaluateLine<CR>
xnoremap <silent> <LocalLeader>r :<C-u>MagmaEvaluateVisual<CR>
nnoremap <silent> <LocalLeader>rc :MagmaReevaluateCell<CR>
This way, <LocalLeader>r
will behave just like standard keys such as y
and d
.
You can, of course, also map other commands:
nnoremap <silent> <LocalLeader>rd :MagmaDelete<CR>
nnoremap <silent> <LocalLeader>ro :MagmaShowOutput<CR>
nnoremap <silent> <LocalLeader>rq :noautocmd MagmaEnterOutput<CR>
Customization is done via variables.
Defaults to "none"
.
This configures how to display images. The following options are available:
"none"
-- don't show images."ueberzug"
-- use Ueberzug to display images."kitty"
-- use the Kitty protocol to display images.
Defaults to v:true
.
If this is true, then whenever you have an active cell its output window will be automatically shown.
If this is false, then the output window will only be automatically shown when you've just evaluated the code. So, if you take your cursor out of the cell, and then come back, the output window won't be opened (but the cell will be highlighted). This means that there will be nothing covering your code. You can then open the output window at will using :MagmaShowOutput
.
Defaults to v:true
.
If this is true, then text output in the output window will be wrapped (akin to set wrap
).
Defaults to v:true
.
If this is true, then the output window will have rounded borders. If it is false, it will have no borders.
Defaults to "CursorLine"
.
The highlight group to be used for highlighting cells.
Defaults to stdpath("data") .. "/magma"
.
Where to save/load with :MagmaSave
and :MagmaLoad
(with no parameters).
The generated file is placed in this directory, with the filename itself being the buffer's name, with %
replaced by %%
and /
replaced by %
, and postfixed with the extension .json
.
Defaults to v:false
.
To copy the evaluation output to clipboard automatically.
Defaults to v:false
.
If this is true, then before any non-iostream output chunk, Magma shows the mimetypes it received for it.
This is meant for debugging and adding new mimetypes.
We provide some User
autocommands (see :help User
) for further customization. They are:
MagmaInitPre
: runs right beforeMagmaInit
initialization happens for a bufferMagmaInitPost
: runs right afterMagmaInit
initialization happens for a bufferMagmaDeinitPre
: runs right beforeMagmaDeinit
deinitialization happens for a bufferMagmaDeinitPost
: runs right afterMagmaDeinit
deinitialization happens for a buffer
In the Jupyter protocol, most output-related messages provide a dictionary of mimetypes which can be used to display the data. Theoretically, a text/plain
field (i.e., plain text) is always present, so we (theoretically) always have that fallback.
Here is a list of the currently handled mimetypes:
text/plain
: Plain text. Shown as text in the output window's buffer.image/png
: A PNG image. Shown according tog:magma_image_provider
.image/svg+xml
: A SVG image. Rendered into a PNG with CairoSVG and shown with Ueberzug.application/vnd.plotly.v1+json
: A Plotly figure. Rendered into a PNG with Plotly + Kaleido and shown with Ueberzug.text/latex
: A LaTeX formula. Rendered into a PNG with pnglatex and shown with Ueberzug.
This already provides quite a bit of basic functionality. As development continues, more mimetypes will be added.
We use the vim.notify
API. This means that you can use plugins such as rcarriga/nvim-notify for pretty notifications.