When the remote server is actually 'localhost' we can behave better ...

news/2 Fixes/1551.md

@@ -0,0 +1 @@
+Use the appropriate directory for a notebook if remoting to 'localhost'

news/2 Fixes/8285.md

@@ -0,0 +1 @@
+Support intellisense after connecting to a remote server (defaults to active python interpreter)

src/client/datascience/jupyter/kernels/jupyterKernelService.ts

@@ -66,7 +66,12 @@ export class JupyterKernelService {
         var specFile: string | undefined = undefined;
 
         // If the spec file doesn't exist or is not defined, we need to register this kernel
-        if (kernel.kind !== 'connectToLiveKernel' && kernel.kernelSpec && kernel.interpreter) {
+        if (
+            kernel.kind !== 'connectToLiveKernel' &&
+            kernel.kind != 'startUsingRemoteKernelSpec' &&
+            kernel.kernelSpec &&
+            kernel.interpreter
+        ) {
             // Default to the kernel spec file.
             specFile = kernel.kernelSpec.specFile;
 

src/client/datascience/jupyter/kernels/kernel.ts

@@ -50,7 +50,13 @@ import {
     sendTelemetryForPythonKernelExecutable
 } from './helpers';
 import { KernelExecution } from './kernelExecution';
-import { IKernel, isLocalConnection, KernelConnectionMetadata, NotebookCellRunState } from './types';
+import {
+    IKernel,
+    isLocalConnection,
+    isLocalHostConnection,
+    KernelConnectionMetadata,
+    NotebookCellRunState
+} from './types';
 import { SysInfoReason } from '../../interactive-common/interactiveWindowTypes';
 import { MARKDOWN_LANGUAGE } from '../../../common/constants';
 import { InteractiveWindowView } from '../../notebook/constants';
@@ -837,7 +843,11 @@ export class Kernel implements IKernel {
 
     private async updateWorkingDirectoryAndPath(launchingFile?: string): Promise<void> {
         traceInfo('UpdateWorkingDirectoryAndPath in Kernel');
-        if (isLocalConnection(this.kernelConnectionMetadata)) {
+        if (
+            (isLocalConnection(this.kernelConnectionMetadata) ||
+                isLocalHostConnection(this.kernelConnectionMetadata)) &&
+            this.kernelConnectionMetadata.kind !== 'connectToLiveKernel' // Skip for live kernel. Don't change current directory on a kernel that's already running
+        ) {
             let suggestedDir = await calculateWorkingDirectory(this.configService, this.workspaceService, this.fs);
             if (suggestedDir && (await this.fs.localDirectoryExists(suggestedDir))) {
                 // We should use the launch info directory. It trumps the possible dir
@@ -855,7 +865,8 @@ export class Kernel implements IKernel {
     // Update both current working directory and sys.path with the desired directory
     private async changeDirectoryIfPossible(directory: string): Promise<void> {
         if (
-            isLocalConnection(this.kernelConnectionMetadata) &&
+            (isLocalConnection(this.kernelConnectionMetadata) ||
+                isLocalHostConnection(this.kernelConnectionMetadata)) &&
             isPythonKernelConnection(this.kernelConnectionMetadata)
         ) {
             traceInfo('changeDirectoryIfPossible');

src/client/datascience/jupyter/kernels/types.ts

@@ -16,6 +16,7 @@ import type {
     KernelSocketInformation
 } from '../../types';
 import type * as nbformat from '@jupyterlab/nbformat';
+import * as url from 'url';
 
 export type LiveKernelModel = IJupyterKernel &
     Partial<IJupyterKernelSpec> & { model: Session.IModel | undefined; notebook?: { path?: string } };
@@ -63,7 +64,7 @@ export type LocalKernelSpecConnectionMetadata = Readonly<{
  */
 export type RemoteKernelSpecConnectionMetadata = Readonly<{
     kernelModel?: undefined;
-    interpreter?: undefined;
+    interpreter?: PythonEnvironment; // Can be set if URL is localhost
     kernelSpec: IJupyterKernelSpec;
     kind: 'startUsingRemoteKernelSpec';
     baseUrl: string;
@@ -112,6 +113,14 @@ export function isLocalConnection(
     );
 }
 
+export function isLocalHostConnection(kernelConnection: KernelConnectionMetadata): boolean {
+    if (kernelConnection.kind === 'connectToLiveKernel' || kernelConnection.kind === 'startUsingRemoteKernelSpec') {
+        const parsed = new url.URL(kernelConnection.baseUrl);
+        return parsed.hostname.toLocaleLowerCase() === 'localhost' || parsed.host === '127.0.0.1';
+    }
+    return false;
+}
+
 export interface IKernel extends IAsyncDisposable {
     readonly connection: INotebookProviderConnection | undefined;
     readonly notebookDocument: NotebookDocument;

src/client/datascience/kernel-launcher/remoteKernelFinder.ts

@@ -4,6 +4,7 @@
 
 import { Kernel } from '@jupyterlab/services';
 import type * as nbformat from '@jupyterlab/nbformat';
+import * as url from 'url';
 import { injectable, inject } from 'inversify';
 import { CancellationToken } from 'vscode';
 import { IDisposableRegistry, Resource } from '../../common/types';
@@ -30,6 +31,7 @@ import { PYTHON_LANGUAGE } from '../../common/constants';
 import { getTelemetrySafeLanguage } from '../../telemetry/helpers';
 import { sendKernelListTelemetry } from '../telemetry/kernelTelemetry';
 import { ignoreLogging } from '../../logging/trace';
+import { IInterpreterService } from '../../interpreter/contracts';
 
 // This class searches for a kernel that matches the given kernel name.
 // First it searches on a global persistent state, then on the installed python interpreters,
@@ -44,7 +46,8 @@ export class RemoteKernelFinder implements IRemoteKernelFinder {
         @inject(IDisposableRegistry) disposableRegistry: IDisposableRegistry,
         @inject(PreferredRemoteKernelIdProvider)
         private readonly preferredRemoteKernelIdProvider: PreferredRemoteKernelIdProvider,
-        @inject(IJupyterSessionManagerFactory) private jupyterSessionManagerFactory: IJupyterSessionManagerFactory
+        @inject(IJupyterSessionManagerFactory) private jupyterSessionManagerFactory: IJupyterSessionManagerFactory,
+        @inject(IInterpreterService) private interpreterService: IInterpreterService
     ) {
         disposableRegistry.push(
             this.jupyterSessionManagerFactory.onRestartSessionCreated(this.addKernelToIgnoreList.bind(this))
@@ -120,15 +123,18 @@ export class RemoteKernelFinder implements IRemoteKernelFinder {
                 ]);
 
                 // Turn them both into a combined list
-                const mappedSpecs = specs.map((s) => {
-                    const kernel: RemoteKernelSpecConnectionMetadata = {
-                        kind: 'startUsingRemoteKernelSpec',
-                        kernelSpec: s,
-                        id: getKernelId(s, undefined, connInfo.baseUrl),
-                        baseUrl: connInfo.baseUrl
-                    };
-                    return kernel;
-                });
+                const mappedSpecs = await Promise.all(
+                    specs.map(async (s) => {
+                        const kernel: RemoteKernelSpecConnectionMetadata = {
+                            kind: 'startUsingRemoteKernelSpec',
+                            interpreter: await this.getInterpreter(s, connInfo.baseUrl),
+                            kernelSpec: s,
+                            id: getKernelId(s, undefined, connInfo.baseUrl),
+                            baseUrl: connInfo.baseUrl
+                        };
+                        return kernel;
+                    })
+                );
                 const mappedLive = sessions.map((s) => {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const liveKernel = s.kernel as any;
@@ -196,4 +202,12 @@ export class RemoteKernelFinder implements IRemoteKernelFinder {
         this.kernelIdsToHide.delete(kernel.id);
         this.kernelIdsToHide.delete(kernel.clientId);
     }
+
+    private async getInterpreter(spec: IJupyterKernelSpec, baseUrl: string) {
+        const parsed = new url.URL(baseUrl);
+        if (parsed.hostname.toLocaleLowerCase() === 'localhost' || parsed.hostname === '127.0.0.1') {
+            // Interpreter is possible. Same machine as VS code
+            return this.interpreterService.getInterpreterDetails(spec.argv[0]);
+        }
+    }
 }

src/client/datascience/notebook/intellisense/intellisenseProvider.ts

@@ -168,7 +168,18 @@ export class IntellisenseProvider implements INotebookLanguageClientProvider, IE
         const notebookInterpreter = controller
             ? controller.connection.interpreter
             : this.getActiveInterpreterSync(uri.fsPath);
-        const notebookId = notebookInterpreter ? this.getInterpreterIdFromCache(notebookInterpreter) : undefined;
+        let notebookId = notebookInterpreter ? this.getInterpreterIdFromCache(notebookInterpreter) : undefined;
+
+        // Special case. For remote use the active interpreter as the controller's interpreter isn't
+        // usable by pylance.
+        if (
+            interpreterId !== notebookId &&
+            (controller?.connection.kind === 'startUsingRemoteKernelSpec' ||
+                controller?.connection.kind === 'connectToLiveKernel')
+        ) {
+            const activeInterpreter = this.getActiveInterpreterSync(uri.fsPath);
+            notebookId = activeInterpreter ? this.getInterpreterIdFromCache(activeInterpreter) : undefined;
+        }
 
         return interpreterId == notebookId;
     }

src/client/datascience/telemetry/interpreterPackageTracker.ts

@@ -6,10 +6,9 @@ import { NotebookDocument } from 'vscode';
 import { IExtensionSingleActivationService } from '../../activation/types';
 import { IPythonInstaller, IPythonExtensionChecker, IPythonApiProvider } from '../../api/types';
 import { InterpreterUri } from '../../common/installer/types';
-import { IExtensions, IDisposableRegistry, Product, IConfigurationService } from '../../common/types';
+import { IExtensions, IDisposableRegistry, Product } from '../../common/types';
 import { isResource, noop } from '../../common/utils/misc';
 import { IInterpreterService } from '../../interpreter/contracts';
-import { isLocalLaunch } from '../jupyter/kernels/helpers';
 import { InterpreterPackages } from './interpreterPackages';
 import { INotebookControllerManager } from '../notebook/types';
 import { VSCodeNotebookController } from '../notebook/vscodeNotebookController';
@@ -26,13 +25,9 @@ export class InterpreterPackageTracker implements IExtensionSingleActivationServ
         @inject(IDisposableRegistry) private readonly disposables: IDisposableRegistry,
         @inject(IInterpreterService) private readonly interpreterService: IInterpreterService,
         @inject(IPythonApiProvider) private readonly apiProvider: IPythonApiProvider,
-        @inject(IConfigurationService) private readonly configurationService: IConfigurationService,
         @inject(INotebookControllerManager) private readonly notebookControllerManager: INotebookControllerManager
     ) {}
     public async activate(): Promise<void> {
-        if (!isLocalLaunch(this.configurationService)) {
-            return;
-        }
         this.notebookControllerManager.onNotebookControllerSelected(
             this.onNotebookControllerSelected,
             this,

src/test/datascience/kernel-launcher/remoteKernelFinder.unit.test.ts

@@ -24,13 +24,15 @@ import { JupyterSessionManagerFactory } from '../../../client/datascience/jupyte
 import { JupyterSessionManager } from '../../../client/datascience/jupyter/jupyterSessionManager';
 import { noop } from '../../core';
 import { LiveKernelConnectionMetadata } from '../../../client/datascience/jupyter/kernels/types';
+import { IInterpreterService } from '../../../client/interpreter/contracts';
 
 suite(`Remote Kernel Finder`, () => {
     let disposables: Disposable[] = [];
     let preferredRemoteKernelIdProvider: PreferredRemoteKernelIdProvider;
     let kernelFinder: IRemoteKernelFinder;
     let jupyterSessionManager: IJupyterSessionManager;
     const dummyEvent = new EventEmitter<number>();
+    let interpreterService: IInterpreterService;
     let sessionCreatedEvent: EventEmitter<Kernel.IKernelConnection>;
     let sessionUsedEvent: EventEmitter<Kernel.IKernelConnection>;
     const connInfo: IJupyterConnection = {
@@ -108,11 +110,13 @@ suite(`Remote Kernel Finder`, () => {
         sessionUsedEvent = new EventEmitter<Kernel.IKernelConnection>();
         when(jupyterSessionManagerFactory.onRestartSessionCreated).thenReturn(sessionCreatedEvent.event);
         when(jupyterSessionManagerFactory.onRestartSessionUsed).thenReturn(sessionUsedEvent.event);
+        interpreterService = mock<IInterpreterService>();
 
         kernelFinder = new RemoteKernelFinder(
             disposables,
             preferredRemoteKernelIdProvider,
-            instance(jupyterSessionManagerFactory)
+            instance(jupyterSessionManagerFactory),
+            instance(interpreterService)
         );
     });
     teardown(() => {

src/test/datascience/notebook/remoteNotebookEditor.vscode.test.ts

@@ -334,4 +334,32 @@ suite('DataScience - VSCode Notebook - (Remote) (Execution) (slow)', function ()
         const cell = vscodeNotebook.activeNotebookEditor?.document.cellAt(0)!;
         await Promise.all([runCell(cell), waitForTextOutput(cell, '123412341234')]);
     });
+
+    test('Remote kernels support intellisense', async function () {
+        await openNotebook(ipynbFile.fsPath);
+        await waitForKernelToGetAutoSelected(PYTHON_LANGUAGE);
+        let nbEditor = vscodeNotebook.activeNotebookEditor!;
+        assert.isOk(nbEditor, 'No active notebook');
+        // Cell 1 = `a = "Hello World"`
+        // Cell 2 = `print(a)`
+        let cell2 = nbEditor.document.getCells()![1]!;
+        await Promise.all([
+            runAllCellsInActiveNotebook(),
+            waitForExecutionCompletedSuccessfully(cell2),
+            waitForTextOutput(cell2, 'Hello World', 0, false)
+        ]);
+
+        // Wait for tokens on the second cell (it works with just plain pylance)
+        await waitForCondition(
+            async () => {
+                const promise = commands.executeCommand('vscode.provideDocumentSemanticTokens', cell2.document.uri);
+                const result = (await promise) as any;
+                return result && result.data.length > 0;
+            },
+            defaultNotebookTestTimeout,
+            `Tokens never appear for first cell`,
+            100,
+            true
+        );
+    });
 });