Create a remote file system/explrorer (Jupyter Lab behavior)

[rchiodo]

There's been a number of bugs/requests for this:
https://github.com/microsoft/vscode-python/issues/9065
https://github.com/microsoft/vscode-python/issues/9043
https://github.com/microsoft/vscode-python/issues/7956
https://github.com/microsoft/vscode-python/issues/9620

I believe we could implement a remote file system for a remote server URI and then we'd behave the way customers want (and incidentally do the same thing Jupyter Lab does here)

[rchiodo]

The relevant VS code API is this one:
https://code.visualstudio.com/api/references/vscode-api#FileSystemProvider

The relevant Jupyter API is this one:
https://jupyterlab.github.io/jupyterlab/services/classes/contentsmanager.html

[rchiodo]

Imagine a scenario where a Jupyter Lab (or hub) user just sends a URI to a VS code user. It opens the entire workspace from that URI.

[javiqm12]

I think the implementation of these features would be fantastic!
Power functions of an IDE with flexibility of Jupyter notebooks, I like it very much!

[jingxuanlim]

Yes, so far this is the first major roadblock I've encountered when I tried out VS Code and is what is preventing me from switching. I would like to be able to access notebooks (the way I am able to with Jupyter notebook and Jupyter lab) on the remote file system.

I think the implementation of these features would be fantastic!
Power functions of an IDE with flexibility of Jupyter notebooks, I like it very much!

I've still got lots to explore on VS Code, in terms of using Jupyter notebooks on it; but I agree with @javiqm12: if VS Code is basically Jupyter lab (with none of the major functions missing) but with added IDE functions, that would be the most ideal.

[bradezard131]

Big ups on this feature. I can imagine very few scenarios in which I wouldn't want to do something with the filesystem if I'm sending work to a remote server. Even if I'm storing my code locally I will probably have data on the remote that may need to be examined and having no direct way of doing that is a stopping point. I'm actively looking for an alternative to JupyterLab (need autocomplete that's worth a damn) but so far every project has this issue of no filesystem access.

[eduDorus]

Same here, thumbs up!

[brsoyanvn]

Looking forward for this feature too!

[sergei3000]

This would be an awesome feature for our team of 100+ data scientists

[minsa110]

Noting two of the major pain points / expectations from talking to our users:

1. While executing nb with a remote kernel, refer to local files

This is especially a pain point for developers in DS/ML teams that test code locally before connecting to a remote kernel for a scalable / cloud dev environment that provides powerful (or more specific) compute & persistent storage. In these cases, users want and need fast access to notebooks and other related work artifacts on the local file system so that they can "continue" their work. The confusion in the VS Code UI is that it only shows files in the local system (not the one in remote kernels), even though the users cannot access them when they're connected to a remote kernel. Here are verbatims as examples of user frustrations:

If you want to for example call a function from another python file (foo.py) from that notebook (local-notebook.ipynb), the remote kernel can't access local files. The remote kernel can access other files saved on the remote notebook server. The problem is that local (Python) files are not synced with the remote Jupyter server instance, for the remote Python interpreter (kernel) to access them (vscode-jupyter#1601)

wirte csv in remote server save the file in remote server, not in local file. If there is a download tool would be very useful
This is also a pain point when debugging a local notebook using remote kernel as well:

Debugging notebooks when using a ssh remote server doesn't work properly. When trying to Run by line, a lot of times it doesn't stop at any line. Also 'Step into' almost never work for me.

2. While executing nb with a remote kernel, navigate remote files through the UI

The current way of exploring remote files in VS Code is not very UI-friendly when connected to a remote kernel. Users would have to use cell magics through the os library, which isn't the best experience (and also confusing because the output (obviously) doesn't match what's shown on the VS Code file explorer). Being able to access remote files is not only common in professional DS/ML teams, but also in academics where educators set up and manage multiple Jupyter servers for class. This is actually something that other products do by default. DataSpell is a desktop-based product and an example of this:

Though, other web-based products do this as well (mostly by default, since you already have to be connected to a remote kernel when loading the nb UI)

Related to this, is the ability to see and manage the Python environment on the remote kernel without having to SSH into the server, and some verbatims to go with this ask:

Having some capability see the python environment on the other side would avoid having to create that environment locally just to resolve dependencies for my code..

As a new capability for the notebook experience in VS Code, I would like to see integration with remote file browsing

Proposals for exploration:

• We should explore enabling users to refer to local files from the nb without having to upload them to the remote server. This way, users would not need to make any potential code changes to refer to the right file structure. (Open q: when user types pd.read_csv('./data.csv'), how would users indicate that they're referring to local file vs. remote one?)
• We could also explore a smooth "continue on" like transition (e.g. automatic sync) UX where we'd walk the user through uploading their local files to the remote server (automating most / obvious parts of this flow). The file explorer would then "refresh" to show the latest local files that have just been uploaded to remote

[Reapor-Yurnero]

Imagine a scenario where a Jupyter Lab (or hub) user just sends a URI to a VS code user. It opens the entire workspace from that URI.

Precisely. It would be very helpful if we can have something like this.

[andrewjlevin]

Is there any update on this? At a bare minimum, is there a way to open remote files through an ipython terminal?

[snami100]

any news about the progress of this feature?

Would be great if we had something like in PyCharm
https://user-images.githubusercontent.com/49515753/274517581-44f19f02-8629-4020-918e-85488b28a1b2.png

[DonJayamanne]

Notes:

• Discoverability of VS Code Server & Tunnels
  • In a number of issues I've suggested the above and users have been happy with this.
• VS Code Serer/Tunnel is not an option
  • Users do not have access to install additional software
• Users would like to just view/manage remote files

Solution(s)

• KISS - View/Manage remote files via file explorer (using the FileSystemProvider API)
  • Focus on just the remote file system view, without syncing,
  • Ability to view local files on the remote server will not be part of this (i.e. syncing files is out of scope for now)

Challenges

• Discoverability
  • How will users know that they can view files on the remote server?
  • 1. Will a simple command (in command palette) suffice?
  • 2. How about interatinmg Manage Kernels view, turn this into Manage Jupyter Servers
    • Here users can manage local kernels/ remote kernels
    • They can also see the remote files as part of the tree view
    • They can see icons that will allow them to mount the files system provider as well
    • Given that some users already know about the this UI, it is easily discoverable, similar to Docker panel

[zhangzw16]

Any update on this feature? Really need it!!

[matpompili]

+1

[dataspekulant]

This could be a real game changer.