Provide option to auto-install DVC if unavailable (#2944)

* update get started webview with new skeleton

* add static options for screen

* wire up select python interpreter

* add rough implementation for installing dvc

* reverse installing of DVCLive and DVC

* move auto install

* refactor

* show loading screen while DVC tries to load experiments data

* add further tests

* self review

* apply review suggestion

Author: mattseddon

extension/src/experiments/index.ts

@@ -497,7 +497,7 @@ export class Experiments extends BaseRepository<TableData> {
 
   public getHasData() {
     if (this.deferred.state === 'none') {
-      return false
+      return
     }
     return this.columns.hasNonDefaultColumns()
   }

extension/src/experiments/workspace.ts

@@ -329,9 +329,19 @@ export class WorkspaceExperiments extends BaseWorkspaceWebviews<
   }
 
   public getHasData() {
-    return Object.values(this.repositories).some(repository =>
-      repository.getHasData()
-    )
+    const allLoading = undefined
+
+    const repositories = Object.values(this.repositories)
+
+    if (repositories.some(repository => repository.getHasData())) {
+      return true
+    }
+
+    if (repositories.some(repository => repository.getHasData() === false)) {
+      return false
+    }
+
+    return allLoading
   }
 
   private async pickExpThenRun(

extension/src/extension.ts

@@ -241,6 +241,7 @@ export class Extension extends Disposable implements IExtension {
       this.config.onDidChangeExecutionDetails(async () => {
         const stopWatch = new StopWatch()
         try {
+          this.changeSetupStep()
           await setup(this)
 
           return sendTelemetryEvent(

extension/src/extensions/python.ts

@@ -1,5 +1,5 @@
 import { commands, Event, Uri } from 'vscode'
-import { executeProcess } from '../processExecution'
+import { findPythonBin } from '../python'
 import { getExtensionAPI, isInstalled } from '../vscode/extensions'
 
 const PYTHON_EXTENSION_ID = 'ms-python.python'
@@ -38,13 +38,7 @@ export const getPythonBinPath = async (): Promise<string | undefined> => {
   const pythonExecutionDetails = await getPythonExecutionDetails()
   const pythonBin = pythonExecutionDetails?.join(' ')
   if (pythonBin) {
-    try {
-      return await executeProcess({
-        args: ['-c', 'import sys; print(sys.executable)'],
-        cwd: process.cwd(),
-        executable: pythonBin
-      })
-    } catch {}
+    return findPythonBin(pythonBin)
   }
 }
 

extension/src/fileSystem/index.ts

@@ -1,4 +1,4 @@
-import { basename, extname, join, relative, resolve } from 'path'
+import { basename, extname, join, relative, resolve, sep } from 'path'
 import {
   ensureFileSync,
   existsSync,
@@ -16,6 +16,7 @@ import { Logger } from '../common/logger'
 import { gitPath } from '../cli/git/constants'
 import { createValidInteger } from '../util/number'
 import { processExists } from '../processExecution'
+import { getFirstWorkspaceFolder } from '../vscode/workspaceFolders'
 
 export const exists = (path: string): boolean => existsSync(path)
 
@@ -164,3 +165,20 @@ export const checkSignalFile = async (path: string): Promise<boolean> => {
 
   return true
 }
+
+export const getBinDisplayText = (
+  path: string | undefined
+): string | undefined => {
+  if (!path) {
+    return
+  }
+
+  const workspaceRoot = getFirstWorkspaceFolder()
+  if (!workspaceRoot) {
+    return path
+  }
+
+  return isSameOrChild(workspaceRoot, path)
+    ? '.' + sep + relative(workspaceRoot, path)
+    : path
+}

extension/src/python/index.ts

@@ -3,45 +3,67 @@ import { getVenvBinPath } from './path'
 import { getProcessPlatform } from '../env'
 import { exists } from '../fileSystem'
 import { Logger } from '../common/logger'
-import { createProcess, Process, ProcessOptions } from '../processExecution'
+import { createProcess, executeProcess, Process } from '../processExecution'
 
-const sendOutput = (process: Process) =>
+const sendOutput = (process: Process) => {
   process.all?.on('data', chunk =>
     Logger.log(chunk.toString().replace(/(\r?\n)/g, ''))
   )
-
-export const createProcessWithOutput = (options: ProcessOptions) => {
-  const process = createProcess(options)
-
-  sendOutput(process)
-
   return process
 }
 
-const installPackages = (cwd: string, pythonBin: string, ...args: string[]) => {
-  return createProcessWithOutput({
+export const installPackages = (
+  cwd: string,
+  pythonBin: string,
+  ...args: string[]
+): Process => {
+  const options = {
     args: ['-m', 'pip', 'install', '--upgrade', ...args],
     cwd,
     executable: pythonBin
-  })
+  }
+
+  return createProcess(options)
 }
 
+export const getDefaultPython = (): string =>
+  getProcessPlatform() === 'win32' ? 'python' : 'python3'
+
 export const setupVenv = async (
   cwd: string,
   envDir: string,
   ...installArgs: string[]
 ) => {
   if (!exists(join(cwd, envDir))) {
-    await createProcessWithOutput({
+    const initVenv = createProcess({
       args: ['-m', 'venv', envDir],
       cwd,
-      executable: getProcessPlatform() === 'win32' ? 'python' : 'python3'
+      executable: getDefaultPython()
     })
+    await sendOutput(initVenv)
   }
 
   const venvPython = getVenvBinPath(cwd, envDir, 'python')
 
-  await installPackages(cwd, venvPython, 'pip', 'wheel')
+  const venvUpgrade = installPackages(cwd, venvPython, 'pip', 'wheel')
+  await sendOutput(venvUpgrade)
+
+  const installRequestedPackages = installPackages(
+    cwd,
+    venvPython,
+    ...installArgs
+  )
+  return sendOutput(installRequestedPackages)
+}
 
-  return installPackages(cwd, venvPython, ...installArgs)
+export const findPythonBin = async (
+  pythonBin: string
+): Promise<string | undefined> => {
+  try {
+    return await executeProcess({
+      args: ['-c', 'import sys; print(sys.executable)'],
+      cwd: process.cwd(),
+      executable: pythonBin
+    })
+  } catch {}
 }

extension/src/setup/autoInstall.ts

@@ -0,0 +1,64 @@
+import { getPythonExecutionDetails } from '../extensions/python'
+import { findPythonBin, getDefaultPython, installPackages } from '../python'
+import { ConfigKey, getConfigValue } from '../vscode/config'
+import { getFirstWorkspaceFolder } from '../vscode/workspaceFolders'
+import { Toast } from '../vscode/toast'
+
+export const findPythonBinForInstall = async (): Promise<
+  string | undefined
+> => {
+  const manualPython = getConfigValue(ConfigKey.PYTHON_PATH)
+
+  const autoPythonDetails = await getPythonExecutionDetails()
+
+  return findPythonBin(
+    manualPython || autoPythonDetails?.join('') || getDefaultPython()
+  )
+}
+
+const showInstallProgress = (
+  root: string,
+  pythonBinPath: string
+): Thenable<unknown> =>
+  Toast.showProgress('Installing packages', async progress => {
+    progress.report({ increment: 0 })
+
+    await Toast.runCommandAndIncrementProgress(
+      async () => {
+        await installPackages(root, pythonBinPath, 'dvclive')
+        return 'DVCLive Installed'
+      },
+      progress,
+      25
+    )
+
+    await Toast.runCommandAndIncrementProgress(
+      async () => {
+        await installPackages(root, pythonBinPath, 'dvc')
+        return 'DVC Installed'
+      },
+      progress,
+      75
+    )
+
+    return Toast.delayProgressClosing()
+  })
+
+export const autoInstallDvc = async (): Promise<unknown> => {
+  const pythonBinPath = await findPythonBinForInstall()
+  const root = getFirstWorkspaceFolder()
+
+  if (!root) {
+    return Toast.showError(
+      'DVC could not be auto-installed because there is no folder open in the workspace'
+    )
+  }
+
+  if (!pythonBinPath) {
+    return Toast.showError(
+      'DVC could not be auto-installed because a Python interpreter could not be located'
+    )
+  }
+
+  return showInstallProgress(root, pythonBinPath)
+}

extension/src/setup/index.ts

@@ -1,21 +1,23 @@
 import { SetupData as TSetupData } from './webview/contract'
 import { WebviewMessages } from './webview/messages'
+import { findPythonBinForInstall } from './autoInstall'
 import { BaseWebview } from '../webview'
 import { ViewKey } from '../webview/constants'
 import { BaseRepository } from '../webview/repository'
 import { Resource } from '../resourceLocator'
+import { isPythonExtensionInstalled } from '../extensions/python'
+import { getBinDisplayText } from '../fileSystem'
 
 export type SetupWebviewWebview = BaseWebview<TSetupData>
 
 export class Setup extends BaseRepository<TSetupData> {
   public readonly viewKey = ViewKey.SETUP
 
   private webviewMessages: WebviewMessages
-  private initProject: () => void
   private showExperiments: () => void
   private getCliAccessible: () => boolean
   private getHasRoots: () => boolean
-  private getHasData: () => boolean
+  private getHasData: () => boolean | undefined
 
   constructor(
     dvcRoot: string,
@@ -24,27 +26,26 @@ export class Setup extends BaseRepository<TSetupData> {
     showExperiments: () => void,
     getCliAccessible: () => boolean,
     getHasRoots: () => boolean,
-    getHasData: () => boolean
+    getHasData: () => boolean | undefined
   ) {
     super(dvcRoot, webviewIcon)
 
-    this.webviewMessages = this.createWebviewMessageHandler()
+    this.webviewMessages = this.createWebviewMessageHandler(initProject)
 
     if (this.webview) {
       this.sendDataToWebview()
     }
+    this.showExperiments = showExperiments
     this.getCliAccessible = getCliAccessible
     this.getHasRoots = getHasRoots
-    this.initProject = initProject
-    this.showExperiments = showExperiments
     this.getHasData = getHasData
   }
 
   public sendInitialWebviewData() {
     return this.sendDataToWebview()
   }
 
-  public sendDataToWebview() {
+  public async sendDataToWebview() {
     const cliAccessible = this.getCliAccessible()
     const projectInitialized = this.getHasRoots()
     const hasData = this.getHasData()
@@ -60,17 +61,21 @@ export class Setup extends BaseRepository<TSetupData> {
       return
     }
 
+    const pythonBinPath = await findPythonBinForInstall()
+
     this.webviewMessages.sendWebviewMessage(
       cliAccessible,
       projectInitialized,
+      isPythonExtensionInstalled(),
+      getBinDisplayText(pythonBinPath),
       hasData
     )
   }
 
-  private createWebviewMessageHandler() {
+  private createWebviewMessageHandler(initProject: () => void) {
     const webviewMessages = new WebviewMessages(
       () => this.getWebview(),
-      () => this.initProject()
+      initProject
     )
     this.dispose.track(
       this.onDidReceivedWebviewMessage(message =>

extension/src/setup/webview/contract.ts

@@ -1,5 +1,7 @@
 export type SetupData = {
   cliAccessible: boolean
+  hasData: boolean | undefined
+  isPythonExtensionInstalled: boolean
   projectInitialized: boolean
-  hasData: boolean
+  pythonBinPath: string | undefined
 }