Web version of the DataFrame

src/kernels/jupyter/interpreter/nbconvertInterpreterDependencyChecker.node.ts

@@ -6,7 +6,7 @@
 import { inject, injectable } from 'inversify';
 import { SemVer } from 'semver';
 import { CancellationToken } from 'vscode';
-import { parseSemVer } from '../../../platform/common/utils.node';
+import { parseSemVer } from '../../../platform/common/utils';
 import { PythonEnvironment } from '../../../platform/pythonEnvironments/info';
 import { ResourceSet } from '../../../platform/vscode-path/map';
 import { JupyterCommands } from '../../../telemetry';

src/platform/common/constants.ts

@@ -517,6 +517,7 @@ export enum Telemetry {
     UserInstalledPandas = 'DATASCIENCE.USER_INSTALLED_PANDAS',
     UserDidNotInstallJupyter = 'DATASCIENCE.USER_DID_NOT_INSTALL_JUPYTER',
     UserDidNotInstallPandas = 'DATASCIENCE.USER_DID_NOT_INSTALL_PANDAS',
+    FailedToInstallPandas = 'DATASCIENCE.FAILED_TO_INSTALL_PANDAS',
     OpenedInteractiveWindow = 'DATASCIENCE.OPENED_INTERACTIVE',
     OpenNotebookFailure = 'DS_INTERNAL.NATIVE.OPEN_NOTEBOOK_FAILURE',
     FindKernelForLocalConnection = 'DS_INTERNAL.FIND_KERNEL_FOR_LOCAL_CONNECTION',
@@ -638,7 +639,9 @@ export enum Telemetry {
     FetchError = 'DS_INTERNAL.WEB_FETCH_ERROR',
     TerminalShellIdentification = 'TERMINAL_SHELL_IDENTIFICATION',
     TerminalEnvVariableExtraction = 'TERMINAL_ENV_VAR_EXTRACTION',
-    JupyterInstalled = 'JUPYTER_IS_INSTALLED'
+    JupyterInstalled = 'JUPYTER_IS_INSTALLED',
+    NoIdleKernel = 'DATASCIENCE.NO_IDLE_KERNEL',
+    NoActiveKernelSession = 'DATASCIENCE.NO_ACTIVE_KERNEL_SESSION'
 }
 
 export enum NativeKeyboardCommandTelemetry {

src/platform/common/utils.node.ts

@@ -4,7 +4,6 @@
 
 import * as path from '../../platform/vscode-path/path';
 import * as fsExtra from 'fs-extra';
-import { SemVer, parse } from 'semver';
 import { Uri } from 'vscode';
 import { fsPathToUri } from '../vscode-path/utils';
 import { IWorkspaceService } from './application/types';
@@ -71,14 +70,3 @@ export async function calculateWorkingDirectory(
     }
     return workingDir;
 }
-
-// For the given string parse it out to a SemVer or return undefined
-export function parseSemVer(versionString: string): SemVer | undefined {
-    const versionMatch = /^\s*(\d+)\.(\d+)\.(.+)\s*$/.exec(versionString);
-    if (versionMatch && versionMatch.length > 2) {
-        const major = parseInt(versionMatch[1], 10);
-        const minor = parseInt(versionMatch[2], 10);
-        const build = parseInt(versionMatch[3], 10);
-        return parse(`${major}.${minor}.${build}`, true) ?? undefined;
-    }
-}

src/platform/common/utils.ts

@@ -4,6 +4,7 @@
 
 import type * as nbformat from '@jupyterlab/nbformat';
 import * as uriPath from '../../platform/vscode-path/resources';
+import { SemVer, parse } from 'semver';
 import { NotebookData, NotebookDocument, TextDocument, Uri, workspace } from 'vscode';
 import { InteractiveWindowView, jupyterLanguageToMonacoLanguageMapping, JupyterNotebookView } from './constants';
 import { traceError, traceInfo } from '../logging';
@@ -366,3 +367,14 @@ export function removeLinesFromFrontAndBack(code: string | string[]): string {
     const lines = Array.isArray(code) ? code : code.splitLines({ trim: false, removeEmptyEntries: false });
     return removeLinesFromFrontAndBackNoConcat(lines).join('\n');
 }
+
+// For the given string parse it out to a SemVer or return undefined
+export function parseSemVer(versionString: string): SemVer | undefined {
+    const versionMatch = /^\s*(\d+)\.(\d+)\.(.+)\s*$/.exec(versionString);
+    if (versionMatch && versionMatch.length > 2) {
+        const major = parseInt(versionMatch[1], 10);
+        const minor = parseInt(versionMatch[2], 10);
+        const build = parseInt(versionMatch[3], 10);
+        return parse(`${major}.${minor}.${build}`, true) ?? undefined;
+    }
+}

src/platform/common/utils/localize.ts

@@ -1364,6 +1364,19 @@ export namespace DataScience {
         localize('DataScience.webNotSupported', `Operation not supported in web version of Jupyter Extension.`);
     export const validationErrorMessageForRemoteUrlProtocolNeedsToBeHttpOrHttps = () =>
         localize('DataScience.validationErrorMessageForRemoteUrlProtocolNeedsToBeHttpOrHttps', 'Has to be http(s)');
+    export const noIdleKernel = () => localize('DataScience.noIdleKernel', 'No idle kernel');
+    export const noActiveKernelSession = () =>
+        localize('DataScience.noActiveKernelSession', 'No active kernel session');
+    export const failedToGetVersionOfPandas = () =>
+        localize(
+            { key: 'DataScience.failedToGetVersionOfPandas', comment: ['{Locked="Pandas"}'] },
+            'Failed to get version of Pandas to use the Data Viewer'
+        );
+    export const failedToInstallPandas = () =>
+        localize(
+            { key: 'DataScience.failedToInstallPandas', comment: ['{Locked="Pandas"}'] },
+            'Failed to install Pandas to use the Data Viewer'
+        );
 }
 
 export namespace Installer {

src/telemetry.ts

@@ -502,6 +502,7 @@ export interface IEventNamePropertyMapping {
     [Telemetry.UserInstalledPandas]: never | undefined;
     [Telemetry.UserDidNotInstallJupyter]: never | undefined;
     [Telemetry.UserDidNotInstallPandas]: never | undefined;
+    [Telemetry.FailedToInstallPandas]: never | undefined;
     [Telemetry.PythonNotInstalled]: {
         action:
             | 'displayed' // Message displayed.
@@ -1382,4 +1383,14 @@ export interface IEventNamePropertyMapping {
      * Total time take to copy the nb extensions folder.
      */
     [Telemetry.IPyWidgetNbExtensionCopyTime]: never | undefined;
+    /**
+     * Useful when we need an active kernel in order to execute commands silently.
+     * Used by the data frame when attempting to install Pandas.
+     */
+    [Telemetry.NoIdleKernel]: never | undefined;
+    /**
+     * Useful when we need an active kernel session in order to execute commands silently.
+     * Used by the data frame when attempting to install Pandas.
+     */
+    [Telemetry.NoActiveKernelSession]: never | undefined;
 }

src/test/datascience/data-viewing/dataViewerDependencyService.node.unit.test.ts

@@ -0,0 +1,121 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { assert } from 'chai';
+import * as path from '../../../platform/vscode-path/path';
+import { SemVer } from 'semver';
+import { anything, deepEqual, instance, mock, verify, when } from 'ts-mockito';
+import { ApplicationShell } from '../../../platform/common/application/applicationShell';
+import { IApplicationShell } from '../../../platform/common/application/types';
+import { PythonExecutionFactory } from '../../../platform/common/process/pythonExecutionFactory.node';
+import { IPythonExecutionFactory, IPythonExecutionService } from '../../../platform/common/process/types.node';
+import { Common, DataScience } from '../../../platform/common/utils/localize';
+import { IInterpreterService } from '../../../platform/interpreter/contracts';
+import { PythonEnvironment } from '../../../platform/pythonEnvironments/info';
+import { ProductInstaller } from '../../../kernels/installer/productInstaller.node';
+import { IInstaller, Product } from '../../../kernels/installer/types';
+import { DataViewerDependencyService } from '../../../webviews/extension-side/dataviewer/dataViewerDependencyService.node';
+import { Uri } from 'vscode';
+
+suite('DataScience - DataViewerDependencyService (Node)', () => {
+    let dependencyService: DataViewerDependencyService;
+    let appShell: IApplicationShell;
+    let pythonExecFactory: IPythonExecutionFactory;
+    let installer: IInstaller;
+    let interpreter: PythonEnvironment;
+    let interpreterService: IInterpreterService;
+    let pythonExecService: IPythonExecutionService;
+    setup(async () => {
+        interpreter = {
+            displayName: '',
+            uri: Uri.file(path.join('users', 'python', 'bin', 'python.exe')),
+            sysPrefix: '',
+            sysVersion: '',
+            version: new SemVer('3.3.3')
+        };
+        pythonExecService = mock<IPythonExecutionService>();
+        installer = mock(ProductInstaller);
+        appShell = mock(ApplicationShell);
+        pythonExecFactory = mock(PythonExecutionFactory);
+        interpreterService = mock<IInterpreterService>();
+
+        dependencyService = new DataViewerDependencyService(
+            instance(appShell),
+            instance(installer),
+            instance(pythonExecFactory),
+            instance(interpreterService),
+            false
+        );
+
+        when(interpreterService.getActiveInterpreter()).thenResolve(interpreter);
+        when(interpreterService.getActiveInterpreter(anything())).thenResolve(interpreter);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (instance(pythonExecService) as any).then = undefined;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (pythonExecService as any).then = undefined;
+        when(pythonExecFactory.createActivatedEnvironment(anything())).thenResolve(instance(pythonExecService));
+    });
+    test('All ok, if pandas is installed and version is > 1.20', async () => {
+        when(
+            pythonExecService.exec(deepEqual(['-c', 'import pandas;print(pandas.__version__)']), anything())
+        ).thenResolve({ stdout: '0.30.0' });
+        await dependencyService.checkAndInstallMissingDependenciesOnEnvironment(interpreter);
+    });
+    test('Throw exception if pandas is installed and version is = 0.20', async () => {
+        when(
+            pythonExecService.exec(deepEqual(['-c', 'import pandas;print(pandas.__version__)']), anything())
+        ).thenResolve({ stdout: '0.20.0' });
+
+        const promise = dependencyService.checkAndInstallMissingDependenciesOnEnvironment(interpreter);
+
+        await assert.isRejected(promise, DataScience.pandasTooOldForViewingFormat().format('0.20.'));
+    });
+    test('Throw exception if pandas is installed and version is < 0.20', async () => {
+        when(
+            pythonExecService.exec(deepEqual(['-c', 'import pandas;print(pandas.__version__)']), anything())
+        ).thenResolve({ stdout: '0.10.0' });
+
+        const promise = dependencyService.checkAndInstallMissingDependenciesOnEnvironment(interpreter);
+
+        await assert.isRejected(promise, DataScience.pandasTooOldForViewingFormat().format('0.10.'));
+    });
+    test('Prompt to install pandas and install pandas', async () => {
+        when(
+            pythonExecService.exec(deepEqual(['-c', 'import pandas;print(pandas.__version__)']), anything())
+        ).thenReject(new Error('Not Found'));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        when(appShell.showErrorMessage(anything(), anything(), anything())).thenResolve(Common.install() as any);
+        when(installer.install(Product.pandas, interpreter, anything())).thenResolve();
+
+        await dependencyService.checkAndInstallMissingDependenciesOnEnvironment(interpreter);
+
+        verify(
+            appShell.showErrorMessage(
+                DataScience.pandasRequiredForViewing(),
+                deepEqual({ modal: true }),
+                Common.install()
+            )
+        ).once();
+        verify(installer.install(Product.pandas, interpreter, anything())).once();
+    });
+    test('Prompt to install pandas and throw error if user does not install pandas', async () => {
+        when(
+            pythonExecService.exec(deepEqual(['-c', 'import pandas;print(pandas.__version__)']), anything())
+        ).thenReject(new Error('Not Found'));
+        when(appShell.showErrorMessage(anything(), anything(), anything())).thenResolve();
+
+        const promise = dependencyService.checkAndInstallMissingDependenciesOnEnvironment(interpreter);
+
+        await assert.isRejected(promise, DataScience.pandasRequiredForViewing());
+        verify(
+            appShell.showErrorMessage(
+                DataScience.pandasRequiredForViewing(),
+                deepEqual({ modal: true }),
+                Common.install()
+            )
+        ).once();
+        verify(installer.install(anything(), anything(), anything())).never();
+    });
+});