Prompt to install ptvsd when needed (microsoft#6562)

Author: IanMatthewHuff

build/functional-test-requirements.txt

@@ -4,6 +4,4 @@ jupyter
 numpy
 matplotlib
 pandas
-livelossplot
-# This is temporary until these bits are ready
-git+https://s3h4llbub6kmnxk53k53ricbg4n7s6tif3ls6qsywersiroezaea@ptvsd.visualstudio.com/ptvsd-pr/_git/ptvsd-pr@ptvsd_jupyter_cells
+livelossplot

news/1 Enhancements/6378.md

@@ -0,0 +1 @@
+Give the option to install ptvsd if user is missing it and tries to debug

package.nls.json

@@ -307,5 +307,9 @@
  "DataScience.jupyterDebuggerPortNotAvailableError" : "Port {0} cannot be opened for debugging. Please specify a different port in the remoteDebuggerPort setting.",
  "DataScience.jupyterDebuggerPortBlockedError" : "Port {0} cannot be connected to for debugging. Please let port {0} through your firewall.",
  "DataScience.jupyterDebuggerPortNotAvailableSearchError" : "Ports in the range {0}-{1} cannot be found for debugging. Please specify a port in the remoteDebuggerPort setting.",
- "DataScience.jupyterDebuggerPortBlockedSearchError" : "A port cannot be connected to for debugging. Please let ports {0}-{1} through your firewall."
+ "DataScience.jupyterDebuggerPortBlockedSearchError" : "A port cannot be connected to for debugging. Please let ports {0}-{1} through your firewall.",
+ "DataScience.jupyterDebuggerInstallPtvsdNew" : "Pip module ptvsd is required for debugging cells. Install ptvsd and continue to debug cell?",
+ "DataScience.jupyterDebuggerInstallPtvsdUpdate" : "The version of ptvsd installed does not support debugging cells. Update ptvsd to newest version and continue to debug cell?",
+ "DataScience.jupyterDebuggerInstallPtvsdYes" : "Yes",
+ "DataScience.jupyterDebuggerInstallPtvsdNo" : "No"
 }

src/client/common/utils/localize.ts

@@ -234,6 +234,10 @@ export namespace DataScience {
  export const jupyterDebuggerPortBlockedError = localize('DataScience.jupyterDebuggerPortBlockedError', 'Port {0} cannot be connected to for debugging. Please let port {0} through your firewall.');
  export const jupyterDebuggerPortNotAvailableSearchError = localize('DataScience.jupyterDebuggerPortNotAvailableSearchError', 'Ports in the range {0}-{1} cannot be found for debugging. Please specify a port in the remoteDebuggerPort setting.');
  export const jupyterDebuggerPortBlockedSearchError = localize('DataScience.jupyterDebuggerPortBlockedSearchError', 'A port cannot be connected to for debugging. Please let ports {0}-{1} through your firewall.');
+ export const jupyterDebuggerInstallPtvsdNew = localize('DataScience.jupyterDebuggerInstallPtvsdNew', 'Pip module ptvsd is required for debugging cells. Install ptvsd and continue to debug cell?');
+ export const jupyterDebuggerInstallPtvsdUpdate = localize('DataScience.jupyterDebuggerInstallPtvsdUpdate', 'The version of ptvsd installed does not support debugging cells. Update ptvsd to newest version and continue to debug cell?');
+ export const jupyterDebuggerInstallPtvsdYes = localize('DataScience.jupyterDebuggerInstallPtvsdYes', 'Yes');
+ export const jupyterDebuggerInstallPtvsdNo = localize('DataScience.jupyterDebuggerInstallPtvsdNo', 'No');
 }
 
 export namespace DebugConfigStrings {

src/client/datascience/constants.ts

@@ -144,7 +144,10 @@ export enum Telemetry {
  WebviewStyleUpdate = 'DATASCIENCE.WEBVIEW_STYLE_UPDATE',
  WebviewMonacoStyleUpdate = 'DATASCIENCE.WEBVIEW_MONACO_STYLE_UPDATE',
  DataViewerFetchTime = 'DATASCIENCE.DATAVIEWER_FETCH_TIME',
- FindJupyterKernelSpec = 'DATASCIENCE.FIND_JUPYTER_KERNEL_SPEC'
+ FindJupyterKernelSpec = 'DATASCIENCE.FIND_JUPYTER_KERNEL_SPEC',
+ PtvsdPromptToInstall = 'DATASCIENCE.PTVSD_PROMPT_TO_INSTALL',
+ PtvsdSuccessfullyInstalled = 'DATASCIENCE.PTVSD_SUCCESSFULLY_INSTALLED',
+ PtvsdInstallFailed = 'DATASCIENCE.PTVSD_INSTALL_FAILED'
 }
 
 export namespace HelpLinks {

src/client/datascience/jupyter/jupyterDebugger.ts

@@ -4,17 +4,21 @@
 import { nbformat } from '@jupyterlab/coreutils';
 import { inject, injectable } from 'inversify';
 import * as net from 'net';
+import * as path from 'path';
 import * as uuid from 'uuid/v4';
 import { DebugConfiguration } from 'vscode';
 import * as vsls from 'vsls/vscode';
 
-import { ICommandManager, IDebugService, IWorkspaceService } from '../../common/application/types';
-import { traceInfo, traceWarning } from '../../common/logger';
+import { IApplicationShell, ICommandManager, IDebugService, IWorkspaceService } from '../../common/application/types';
+import { traceError, traceInfo, traceWarning } from '../../common/logger';
 import { IPlatformService } from '../../common/platform/types';
 import { IConfigurationService } from '../../common/types';
 import { createDeferred } from '../../common/utils/async';
+import * as localize from '../../common/utils/localize';
+import { EXTENSION_ROOT_DIR } from '../../constants';
+import { captureTelemetry, sendTelemetryEvent } from '../../telemetry';
 import { concatMultilineString } from '../common';
-import { Identifiers, Settings } from '../constants';
+import { Identifiers, Settings, Telemetry } from '../constants';
 import {
  CellState,
  ICell,
@@ -30,10 +34,18 @@ import { JupyterDebuggerPortBlockedError } from './jupyterDebuggerPortBlockedErr
 import { JupyterDebuggerPortNotAvailableError } from './jupyterDebuggerPortNotAvailableError';
 import { ILiveShareHasRole } from './liveshare/types';
 
+interface IPtvsdVersion {
+ major: number;
+ minor: number;
+ revision: string;
+}
+
 @injectable()
 export class JupyterDebugger implements IJupyterDebugger, ICellHashListener {
+ private requiredPtvsdVersion: IPtvsdVersion = { major: 4, minor: 3, revision: '' };
  private configs: Map<string, DebugConfiguration> = new Map<string, DebugConfiguration>();
  constructor(
+ @inject(IApplicationShell) private appShell: IApplicationShell,
  @inject(IConfigurationService) private configService: IConfigurationService,
  @inject(ICommandManager) private commandManager: ICommandManager,
  @inject(IDebugService) private debugService: IDebugService,
@@ -47,7 +59,6 @@ export class JupyterDebugger implements IJupyterDebugger, ICellHashListener {
 
  // Try to connect to this server
  const config = await this.connect(server);
-
  if (config) {
  // First check if this is a live share session. Skip debugging attach on the guest
  // tslint:disable-next-line: no-any
@@ -111,25 +122,15 @@ export class JupyterDebugger implements IJupyterDebugger, ICellHashListener {
  }
  traceInfo('enable debugger attach');
 
- // Current version of ptvsd doesn't support the source map entries, so we need to have a custom copy
- // on disk somewhere. Append this location to our sys path.
- // tslint:disable-next-line:no-multiline-string
- let extraPath = this.configService.getSettings().datascience.ptvsdDistPath;
- // Escape windows path chars so they end up in the source escaped
- if (this.platform.isWindows && extraPath) {
- extraPath = extraPath.replace('\\', '\\\\');
- }
- if (extraPath) {
- traceInfo(`Adding path for ptvsd - ${extraPath}`);
- await this.executeSilently(server, `import sys\r\nsys.path.append('${extraPath}')\r\nsys.path`);
- }
+ // Append any specific ptvsd paths that we have
+ await this.appendPtvsdPaths(server);
 
- // Make sure we can use ptvsd
- const importResults = await this.executeSilently(server, 'import ptvsd');
- if (importResults && importResults.length > 0) {
-  if (importResults[0].state === CellState.error) {
-  throw new JupyterDebuggerNotInstalledError();
- }
+ // Check the version of ptvsd that we have already installed
+ const ptvsdVersion = await this.ptvsdCheck(server);
+
+ // If we don't have ptvsd installed or the version is too old then we need to install it
+ if (!ptvsdVersion || !this.ptvsdMeetsRequirement(ptvsdVersion)) {
+ await this.promptToInstallPtvsd(server, ptvsdVersion);
  }
 
  // Connect local or remote based on what type of server we're talking to
@@ -147,6 +148,47 @@ export class JupyterDebugger implements IJupyterDebugger, ICellHashListener {
  return result;
  }
 
+ // Append our local ptvsd path and ptvsd settings path to sys.path
+ private async appendPtvsdPaths(server: INotebookServer): Promise<void> {
+ const extraPaths: string[] = [];
+
+ // Add the settings path first as it takes precedence over the ptvsd extension path
+ // tslint:disable-next-line:no-multiline-string
+ let settingsPath = this.configService.getSettings().datascience.ptvsdDistPath;
+ // Escape windows path chars so they end up in the source escaped
+ if (settingsPath) {
+ if (this.platform.isWindows) {
+ settingsPath = settingsPath.replace('\\', '\\\\');
+ }
+
+ extraPaths.push(settingsPath);
+ }
+
+ // For a local connection we also need will append on the path to the ptvsd
+ // installed locally by the extension
+ const connectionInfo = server.getConnectionInfo();
+ if (connectionInfo && connectionInfo.localLaunch) {
+ let localPath = path.join(EXTENSION_ROOT_DIR, 'pythonFiles', 'lib', 'python');
+ if (this.platform.isWindows) {
+ localPath = localPath.replace('\\', '\\\\');
+ }
+ extraPaths.push(localPath);
+ }
+
+ if (extraPaths && extraPaths.length > 0) {
+ const pythonPathList = extraPaths.reduce((totalPath, currentPath) => {
+ if (totalPath.length === 0) {
+ totalPath = `'${currentPath}'`;
+ } else {
+ totalPath = `${totalPath}, '${currentPath}'`;
+ }
+
+ return totalPath;
+ }, '');
+ await this.executeSilently(server, `import sys\r\nsys.path.extend([${pythonPathList}])\r\nsys.path`);
+ }
+ }
+
  private buildSourceMap(fileHash: IFileHashes): ISourceMapRequest {
  const sourceMapRequest: ISourceMapRequest = { source: { path: fileHash.file }, pydevdSourceMaps: [] };
 
@@ -166,6 +208,81 @@ export class JupyterDebugger implements IJupyterDebugger, ICellHashListener {
  return server.execute(code, Identifiers.EmptyFileName, 0, uuid(), undefined, true);
  }
 
+ // Returns either the version of ptvsd installed or undefined if not installed
+ private async ptvsdCheck(server: INotebookServer): Promise<IPtvsdVersion | undefined> {
+ // tslint:disable-next-line:no-multiline-string
+ const ptvsdVersionResults = await this.executeSilently(server, `import ptvsd\r\nptvsd.__version__`);
+ return this.parsePtvsdVersionInfo(ptvsdVersionResults);
+ }
+
+ private parsePtvsdVersionInfo(cells: ICell[]): IPtvsdVersion | undefined {
+ if (cells.length < 1 || cells[0].state !== CellState.finished) {
+ return undefined;
+ }
+
+ const targetCell = cells[0];
+
+ const outputString = this.extractOutput(targetCell);
+
+ if (outputString) {
+ // Pull out the version number, note that we can't use SemVer here as python packages don't follow it
+ const packageVersionRegex = /'([0-9]+).([0-9]+).([0-9a-zA-Z]+)/;
+ const packageVersionMatch = packageVersionRegex.exec(outputString);
+
+ if (packageVersionMatch) {
+ return {
+ major: parseInt(packageVersionMatch[1], 10), minor: parseInt(packageVersionMatch[2], 10), revision: packageVersionMatch[3]
+ };
+ }
+ }
+
+ return undefined;
+ }
+
+ // Check to see if the we have the required version of ptvsd to support debugging
+ private ptvsdMeetsRequirement(version: IPtvsdVersion): boolean {
+ if (version.major > this.requiredPtvsdVersion.major) {
+ return true;
+ } else if (version.major === this.requiredPtvsdVersion.major && version.minor >= this.requiredPtvsdVersion.minor) {
+ return true;
+ }
+
+ return false;
+ }
+
+ @captureTelemetry(Telemetry.PtvsdPromptToInstall)
+ private async promptToInstallPtvsd(server: INotebookServer, oldVersion: IPtvsdVersion | undefined): Promise<void> {
+ const promptMessage = oldVersion ? localize.DataScience.jupyterDebuggerInstallPtvsdUpdate() : localize.DataScience.jupyterDebuggerInstallPtvsdNew();
+ const result = await this.appShell.showInformationMessage(promptMessage, localize.DataScience.jupyterDebuggerInstallPtvsdYes(), localize.DataScience.jupyterDebuggerInstallPtvsdNo());
+
+ if (result === localize.DataScience.jupyterDebuggerInstallPtvsdYes()) {
+ await this.installPtvsd(server);
+ } else {
+ // If they don't want to install, throw so we exit out of debugging
+ throw new JupyterDebuggerNotInstalledError();
+ }
+ }
+
+ private async installPtvsd(server: INotebookServer): Promise<void> {
+ // tslint:disable-next-line:no-multiline-string
+ const ptvsdInstallResults = await this.executeSilently(server, `!pip install ptvsd==v4.3.0b1`);
+
+ if (ptvsdInstallResults.length > 0) {
+ const installResultsString = this.extractOutput(ptvsdInstallResults[0]);
+
+ if (installResultsString && installResultsString.includes('Successfully installed')) {
+ sendTelemetryEvent(Telemetry.PtvsdSuccessfullyInstalled);
+ traceInfo('Ptvsd successfully installed');
+ return;
+ }
+ }
+
+ sendTelemetryEvent(Telemetry.PtvsdInstallFailed);
+ traceError('Failed to install ptvsd');
+ // Failed to install ptvsd, throw to exit debugging
+ throw new JupyterDebuggerNotInstalledError();
+ }
+
  // Pull our connection info out from the cells returned by enable_attach
  private parseConnectInfo(cells: ICell[], local: boolean): DebugConfiguration | undefined {
  if (cells.length > 0) {
@@ -226,7 +343,7 @@ export class JupyterDebugger implements IJupyterDebugger, ICellHashListener {
 
  private async connectToLocal(server: INotebookServer): Promise<DebugConfiguration | undefined> {
  // tslint:disable-next-line: no-multiline-string
- const enableDebuggerResults = await this.executeSilently(server, `ptvsd.enable_attach(('localhost', 0))`);
+ const enableDebuggerResults = await this.executeSilently(server, `import ptvsd\r\nptvsd.enable_attach(('localhost', 0))`);
 
  // Save our connection info to this server
  return this.parseConnectInfo(enableDebuggerResults, true);
@@ -241,10 +358,12 @@ export class JupyterDebugger implements IJupyterDebugger, ICellHashListener {
  // Loop through a bunch of ports until we find one we can use. Note how we
  // are connecting to '0.0.0.0' here. That's the location as far as ptvsd is concerned.
  const attachCode = portNumber !== -1 ?
- `ptvsd.enable_attach(('0.0.0.0', ${portNumber}))
+ `import ptvsd
+ptvsd.enable_attach(('0.0.0.0', ${portNumber}))
 print("('${connectionInfo.hostName}', ${portNumber})")` :
  // tslint:disable-next-line: no-multiline-string
- `port = ${Settings.RemoteDebuggerPortBegin}
+ `import ptvsd
+port = ${Settings.RemoteDebuggerPortBegin}
 attached = False
 while not attached and port <= ${Settings.RemoteDebuggerPortEnd}:
  try:

src/client/telemetry/index.ts

@@ -372,6 +372,9 @@ export interface IEventNamePropertyMapping {
  [Telemetry.InterruptJupyterTime]: never | undefined;
  [Telemetry.PandasNotInstalled]: never | undefined;
  [Telemetry.PandasTooOld]: never | undefined;
+ [Telemetry.PtvsdInstallFailed]: never | undefined;
+ [Telemetry.PtvsdPromptToInstall]: never | undefined;
+ [Telemetry.PtvsdSuccessfullyInstalled]: never | undefined;
  [Telemetry.OpenPlotViewer]: never | undefined;
  [Telemetry.Redo]: never | undefined;
  [Telemetry.RemoteAddCode]: never | undefined;