Support a notebook "scratch pad" and/or integrate interactive window experience for notebooks

[rchiodo]

This is similar to gather but without having to run gather.

Sometimes I'm working on a notebook and I add some cells to try something out and I don't want to lose them, but I don't want them in my 'main' notebook.

Additional features:

• Notebook: Add "Run selection" command vscode#200625

[ahmedanis03]

any updates on this?, this is a killer feature to be honest for every data scientist.

[rchiodo]

There was a hackathon project that implemented it but we haven't shipped that yet. It's waiting more up votes I think.

[mischki]

Does anyone have any updates at all?

[rchiodo]

This isn't on our backlog (you can check the milestone to see if we plan to implement it soon).

[thehappycheese]

Keen for this feature please

[erikvdp]

I'd love to have this feature as well!

[tadz-io]

would be great to have this feature. It's the only thing preventing me atm from using VSC for jupyter notebooks...

[aras-y]

I'd love to have this feature!

[mischki]

I'd love to have this feature!

philffm seems to have found a workaround, but I haven't been able to figure out how to implement the first step of getting the notebook kernel's URL in VScode.
If someone could confirm the workaround it would be great.

[rchiodo]

The workaround is to use a 'remote' jupyter server. Essentially you start jupyter yourself on your local machine and then use that to run your kernels.

That allows you to change the kernel to an already running kernel on any notebook or interactive window.

[mischki]

The workaround is to use a 'remote' jupyter server. Essentially you start jupyter yourself on your local machine and then use that to run your kernels.

That allows you to change the kernel to an already running kernel on any notebook or interactive window.

Thank you. This indeed works, but I'm having to create a notebook externally and then connect both the VSCode notebook and the VSCode interactive window to that kernel. It's better than nothing, but gets cumbersome if one needs to run several notebooks at the same time (I routinely have 5-6 actively run notebooks at any given time). So the question is - how could one obtain the URL of the kernel of the notebook started within VSCode, i.e. internally? Then one could simply pass that URL on to the interactive window and voila.

[rchiodo]

So the question is - how could one obtain the URL of the kernel of the notebook started within VSCode, i.e. internally? Then one could simply pass that URL on to the interactive window and voila.

This isn't possible. There isn't one.

However you don't have to open the notebook outside VS code. If you set VS code to use 'remote' (localhost), just open a notebook and run it. The kernel should then appear in the list of kernels for an interactive window if you start it afterwards.

[ulfaslak]

NEED THIS FEATURE! ⚡️⚡️🙏

[Zhivago-Sizov]

@ulfaslak It looks like Jupyter: Create Interactive Window do the job. Just switch the ipykernel in the top right corner manually.

[ulfaslak]

@vuvalini Not in my environment. It creates and connects to a new kernel instance, not the existing one that my notebook runs on.

[Timsaur]

would be a sick feature to have

[abhirajD]

This hasn't yet made it into the plan and still relies on #6765, though still something that we plan to do.

Using a jupyter server created outside vs code is still a reliable workaround though #6484 (comment)

@everyone
What would it take for this feature request to make it to the plan? How does the team select and prioritize external feature requests?

[jaanli]

+1 this would be great! For the debugger especially.

[tapyu]

unfortunately no, this by design

So let them change the design.

[izkula]

I agree this is an essential feature for switching to vscode for data analysis. I would love to see this supported!

[kotarotaniguchi]

+1 - please implement this feature :)

[edobezabb]

Repeating #12162 (comment) comment:

I open up a terminal (in vscode or outside) and run
% jupyter console --existing
and it attaches to the existing running server. I find it work fine that way.

Looks as good workaround until we have the solution implemented in the "interactive window".

[Yefee]

any plan on this？

[Mr-Ruben]

Now it is even easier* than before thanks to
Jupyter PowerToys https://marketplace.visualstudio.com/items?itemName=ms-toolsai.vscode-jupyter-powertoys

* If you are connecting to a Remote Kernel

You can just locate the kernel of your notebook (local or remote) and click "create interactive window" (look carefully inside the image).

I have very few extensions, but this is a useful one.

[Yefee]

Now it is even easier than before thanks to

Jupyter PowerToys https://marketplace.visualstudio.com/items?itemName=ms-toolsai.vscode-jupyter-powertoys

You can just locate the kernel of your notebook (local or remote) and click "create interactive window" (look carefully inside the image).

I have very few extensions, but this is a useful one.

@Mr-Ruben How did you do that? I dont have the "create interactive window" icon.

[Mr-Ruben]

I guess the difference between us is that I was using a 'Remote kernel' (I'm connecting to JupyterLab).
Note the Remote Kernels on my image.

[thehappycheese]

Remote kernel connection is not what this issue is about. Please stop pointing out that that is possible. Nobody wants to start their own kernel every time. VS Code is an IDE. We are asking for some 'integrated' in our 'development environment'

[Yefee]

Remote kernel connection is not what this issue is about. Please stop pointing out that that is possible. Nobody wants to start their own kernel every time. VS Code is an IDE. We are asking for some 'integrated' in our 'development environment'

Even for remote kernel, it is impossible to send code to console and execute using shortcuts like control+z now. That is annoying as well.

[jaanli]

This would be super helpful and is a glaring missing feature, especially for LLM-based workflows that require significant amounts of in-context examples (e.g. for chain-of-thought prompt engineering workflows). Happy to share examples if needed.

[Orilio]

+1 would love to see this implemented

[keithdlandry]

+1
I think the is more or less a must have feature for a huge group of people.
I've tried to switch to VS code for my notebook work multiple times but I always end up switching back to jupyter lab soley for this functionality.

[jaanli]

i gave a talk at @Lightning-AI last week: slides @ https://talks.onefact.org.

i highlighted this as one of the missing features for why i couldn't recommend @microsoft 's vs code :(

demo i gave:

https://colab.research.google.com/github/onefact/loving-the-baseline/blob/main/nearest-neighbors.ipynb

[danielcarlos-ifpen]

Just wanted to add my 10 cents for people who are impatiently waiting for this feature, like me. When you migrate from MATLAB-based workflow to Python-based using VS Code, this honestly becomes one of the most annoying blocking points in the workflow, and things that were once very easy to verify (variables, array lengths, the value on a given index, etc.) now require one or more extra steps that sometimes make me not want to get simple information from my data.

However, for the moment, I am circumventing this problem by always adding a cell that doesn't do much (for example, just a simple debug = 1) and by putting a breakpoint on it. Then, if I need to use a terminal which has the loaded variables of the notebook, I just run this cell in debug mode. This allows me to use the Debug Console as a terminal, which is honestly very useful, especially with its ability of unfolding objects as dictionaries, another feature that some are expecting ( e.g., #1138 ). When in debug mode, you can also open DataFrames with the Data Viewer from the 'Run and Debug' tab. It is still not possible to open variables with Data Wrangler, though, but hopefully this will come with the implementation of an actual terminal designed to work with notebooks.

[Orilio]

However, for the moment, I am circumventing this problem by always adding a cell that doesn't do much (for example, just a simple debug = 1) and by putting a breakpoint on it. Then, if I need to use a terminal which has the loaded variables of the notebook, I just run this cell in debug mode. This allows me to use the Debug Console as a terminal, which is honestly very useful, especially with its ability of unfolding objects as dictionaries, another feature that some are expecting ( e.g., #1138 ). When in debug mode, you can also open DataFrames with the Data Viewer from the 'Run and Debug' tab. It is still not possible to open variables with Data Wrangler, though, but hopefully this will come with the implementation of an actual terminal designed to work with notebooks.

interesting workaround and although it doesn't solve most of my problems, I guess this solve some

[bcalvr]

Has there been any update/progress on this please? +1 to it being a feature that would greatly improve VSCode and is already in many other applications such as JupyterLab

[drakesiardmw]

There was a hackathon project that implemented it but we haven't shipped that yet. It's waiting more up votes I think.

How many more upvotes does this need? Can we get an update on whether there is any plan to deliver this feature?

The current state is that it's possible (as Jupyter Lab does this already) and apparently already implemented (see above comment regarding the hackathon), but not available to users.

[vvatikiotis]

Switched back to JupyterLab just for this. Lack of this feature is a pain. Shame, I like VSCode....

[bcalvr]

There was a hackathon project that implemented it but we haven't shipped that yet. It's waiting more up votes I think.

How many more upvotes does this need? Can we get an update on whether there is any plan to deliver this feature?

The current state is that it's possible (as Jupyter Lab does this already) and apparently already implemented (see above comment regarding the hackathon), but not available to users.

Agreed!

[petrushy]

+1 this is an important feature. To some degree can be compensated with the shell command jupyter console --existing, but that is not the full interactive experience.

[BZandi]

+1

[aftabc]

+1

[rio-raimundo]

+1

[aras-y]

+1

[Yefee]

@amunger @DonJayamanne ,sorry to bother, but any progresses or plans?

[davemaguire]

+1

[Philipp-Blankenhagen]

+1