I noticed that I have many extensions installed that I don't recall manually installing, e.g. isort, jupiter cell tags, etc.
I only installed the "python" and "jupyter notebooks" extensions myself. Those others seem to be installed later without my knowledge.
Does VS Code install extensions automatically somehow?
To answer the general question
Yes, VS Code does come with some extensions installed "out-of-box". It calls those extensions "Built-In" extensions. If you open the extension page of one of those extensions, it will say:
Notice: This extension is bundled with Visual Studio Code. It can be disabled but not uninstalled.
One example of this is the vscode.typescript-language-features extension. You can get a list of all running with the Developer: Show Running Extensions command. It's kind of hard to find them otherwise, since they don't normally show up in the extensions sidebar.
In your particular case, you misunderstood something
The Python and Jupyter extensions you installed are extension packs. They include isort and Jupyter Cell Tags (as well as others).
You can see for yourself.
https://marketplace.visualstudio.com/items?itemName=ms-python.python:
The Python extension will automatically install the Pylance, Jupyter and isort extensions to give you the best experience when working with Python files and Jupyter notebooks.
https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter:
The Jupyter Extension will automatically install the following extensions by default to provide enhanced Jupyter notebook experiences in VS Code.
Jupyter Keymap - to provide Jupyter-consistent keymaps
Jupyter Notebook Renderers - to provide renderers for MIME types such as latex, plotly, vega, etc.
Jupyter Cell Tags and Jupyter Slide Show - to provide the ability to tag cells in notebooks and support for presentations
Related
I have multiple people working on the same AWS EMR cluster to run some Spark jobs. This is being done through Jupyter Notebooks which are created/modified using the Jupyter extension installed on a SSH Target through vscode. The modules are installed on the base conda environment that is included with the /emr/notebook-env/. Some people can see the correct kernel that is associated with the base conda environment in their vscode window when working on notebooks. However, some don't see this kernel as an option. How do I make sure that everyone's vscode lists the appropriate kernel when they are creating new notebooks or modifying existing notebooks?
Another potential reason this could happen is that the Jupyter exentsion of VSCode is not installed.
To add the Jupyter extension for VSCode, search for it by clicking extensions icon in lefthand toolbar, then searching for Jupyter and installing.
The user having the issue had to update their vscode and that fixed the issue
As suggested in the description of the Jupyter Miscrosoft extension for Visual Studio Code (VSC), I come here to ask you about support for cell metadata in jupyter notebooks. It seems nothing is currently available for adding cell metadata and, thus, using the papermill extension when writing python notebooks with VSC.
The last message in this 2019 github discussion, dated 2021-05-28, points to this other discussion where on 2021-05-13 someone suggested to use the Jupyter Powertools extension.
However, as of today 2021-10-03, that extension seems not to be compatible with either of my VSC versions:
VSC 1.60.2
VSC Insiders: 1.61.0
with no updates available for either one of them (using Windows 10).
Is there any way to use papermill with VSC? If not, are you aware of any papermill alternatives for parameterizing notebooks while using VSC?
Thanks
I find extension Jupyter Power Tools that can add tag by click icon tag+ left beside icon python. But it failed in vscode version 1.660
Update - Jupyter Power Tools is now deprecated and functionality to be included within MSFT's Jupyter PowerToys extension. A tags interface / cell metadata editor does not appear to have been included, but they have an open issue here.
I just installed VSCode 1.59.0 along with the Julia, Jupyter, and Python extensions. I am able to create Jupyter notebooks using either Julia or Python. When I create a notebook using Python, I see the variables I create listed in the Jupyter: Variables tab. When I create a notebook using Julia, however, I do not see the variables I create listed anywhere.
At the present moment, while Julia is generally supported in the VS Code Extension, this specific feature is not supported. I have an issue on the Microsoft side and Julia VS Code side open here: https://github.com/microsoft/vscode-jupyter/issues/7224 to hopefully kick start this process.
The Julia VS Code extension does already support this feature outside of Notebooks (when running a ".jl" file) so this should seemingly not be too difficult of a task to port it over to the Jupyter extension, but I am unfamiliar with the level of technical rigor this would require.
I have an issue with VS Code which I recently installed in my MacOS BigSur.
I tried out the Jupyter Notebook extension and in their documentation it says that they have full intellisense support for this extension as well.
Intellisense in Jupyter Notebook in VSCode works well for completing variables, functions,methods,etc....
The only issue I have is that I am not able to get the arguments/parameter information, though it is working fine with the python extension of VSCode
I tried out things like Shift+TAB...which works in JupyterNotebooks(not the VS Code version).
Is this a bug that I am facing...or is it just like that. Can you also please suggest as to how to make this work.
Edit May 12, 2021: With the Pylance language server (now the default), I now get parameters and type hints.
According to this issue on GitHub, the arg/param info is not supported on stable VS Code. It looks like you need to use the "Native Notebook" in VS Code Insiders (the beta) and use the "Pylance" language server Extension.
I haven't tried this solution myself (not sure I want to install Insiders), but just changing the language server to "Pylance" at least gives you signatures.
When I write something in the jupyter notebook markdown field, the typos are not highlighted and often I ended up with something like this:
In almost all IDEs I have used so far, the typos are highlighted with a curly underline which was very convenient for me. Something like this:
Up till now I have not found anything that allows me to see this type of highlights. Does it exist?
The popular Jupyter Notebook bundle extension from Jupyter-contrib contains a spell checker. You can install and enable this (with admin privileges) like so:
pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user
jupyter nbextension enable spellchecker/main
This may be the most popular spell checker for Jupyter Notebooks, but note that it simply highlights words not in its dictionary, and does not offer corrections.
If the extension installed properly, you will see this message in the command line:
Now, in the browser, after opening Jupyter, you will see the button labelled "abc" beside the keyboard button, which you can toggle to enable/disable spell check:
The jupyter-contrib library has many other useful modules such as code folding and table of contents.
Run the following in a terminal:
ipython install-nbextension https://bitbucket.org/ipre/calico/downloads/calico-spell-check-1.0.zip
ipython install-nbextension https://bitbucket.org/ipre/calico/downloads/calico-document-tools-1.0.zip
ipython install-nbextension https://bitbucket.org/ipre/calico/downloads/calico-cell-tools-1.0.zip
jupyter nbextension enable calico-spell-check
You can see typos like
Find out more
Afterwards, you need to activate the spell check in the Jupyter Notebook:
%%javascript
IPython.notebook.config.update({
"load_extensions": {"calico-spell-check":true,
"calico-document-tools":true,
"calico-cell-tools":true
}
})
The spellchecker and some other extensions from jupyter_contrib_nbextensions is incompatible with the ipython version 5.8.0. and later. (Found that it works in some cases for the version 5.0.0 [refer issue page of the same]. I'm not aware of its compatibility for the ipython versions between 5.0.0. to 5.8.0., please do comment if anyone knows).
The calico's nbextension 'spellchecker' available at https://bitbucket.org/ipre/calico/downloads/calico-spell-check-1.0.zip is an outdated version [dated 2015]. But calico had updated their nbextensions and made avaliable at the github repository [latest dated 2018]. It works fine for the ipython version 5.8.0.
Installation
git clone https://github.com/Calysto/notebook-extensions.git
cd notebook-extensions
jupyter nbextension install calysto --user
jupyter nbextension enable calysto/spell-check/main
Check its status:
jupyter nbextension list
When you now open or reload a notebook, there would be a new button visible with a check mark icon next to the button to open the command palette. You may click on it to check the spelling mistakes in the markdown cell.