Use Python Extension's getExecutionDetails to provide venv to reader

.vscode/launch.json

@@ -12,15 +12,13 @@
         "--disable-extensions"
       ],
       "env": {
-        "DVCPATH": ".env/bin/dvc",
         "HOT_RELOAD": "true",
         "PYTHONPATH": ".env/bin/python3",
         "USE_DEV_UI": "true"
       },
       "outFiles": ["${workspaceFolder}/extension/dist/**/*.js"],
       "windows": {
         "env": {
-          "DVCPATH": ".env\\Scripts\\dvc.exe",
           "HOT_RELOAD": "true",
           "PYTHONPATH": ".env\\Scripts\\python.exe",
           "USE_DEV_UI": "true"
@@ -37,15 +35,13 @@
         "${workspaceFolder}/demo"
       ],
       "env": {
-        "DVCPATH": ".env/bin/dvc",
         "HOT_RELOAD": "true",
         "PYTHONPATH": ".env/bin/python3",
         "USE_DEV_UI": "true"
       },
       "outFiles": ["${workspaceFolder}/extension/dist/**/*.js"],
       "windows": {
         "env": {
-          "DVCPATH": ".env\\Scripts\\dvc.exe",
           "HOT_RELOAD": "true",
           "PYTHONPATH": ".env\\Scripts\\python.exe",
           "USE_DEV_UI": "true"

extension/package.json

@@ -85,9 +85,9 @@
       "title": "DVC",
       "properties": {
         "dvc.dvcPath": {
+          "title": "%config.dvcPath.title%",
+          "description": "%config.dvcPath.description%",
           "type": "string",
-          "description": "Path to DVC.",
-          "default": "dvc",
           "scope": "resource"
         }
       }

extension/package.nls.json

@@ -9,6 +9,8 @@
   "command.initNoScm": "Init DVC --no-scm",
   "command.push": "Push",
   "command.runExperiment": "Run Experiment",
-  "command.selectDvcPath": "Select DVC Path",
-  "command.showExperiments": "Show Experiments"
+  "command.selectDvcPath": "Select DVC CLI Path",
+  "command.showExperiments": "Show Experiments",
+  "config.dvcPath.title": "DVC CLI Path",
+  "config.dvcPath.description": "Call DVC from this path. Follows Python Extension when blank."
 }

extension/src/Config.ts

@@ -11,7 +11,7 @@ import {
 import { Disposable } from '@hediet/std/disposable'
 import { makeObservable, observable } from 'mobx'
 import { WebviewColorTheme } from './webviews/experiments/contract'
-import { findCliPath, findDvcRootPaths } from './fileSystem'
+import { findDvcRootPaths } from './fileSystem'
 import { Deferred } from '@hediet/std/synchronization'
 
 export class Config {
@@ -21,7 +21,6 @@ export class Config {
 
   public readonly dispose = Disposable.fn()
   public readonly workspaceRoot: string
-  public dvcCliPath = 'dvc'
   public dvcRootPaths: string[] = []
 
   private onDidChangeEmitter: EventEmitter<ConfigurationChangeEvent>
@@ -48,17 +47,6 @@ export class Config {
     this.dvcPathStatusBarItem.text = path
   }
 
-  private setDvcPaths = async () => {
-    this.updateDvcPathStatusBarItem()
-    await this.setDvcCliPath()
-    return this.findDvcRoots()
-  }
-
-  private setDvcPathsOnActivation = async (dvcPath?: string) => {
-    await this.setDvcPath(dvcPath)
-    return this.setDvcPaths()
-  }
-
   private getWorkspaceRoot = (): string => {
     const { workspaceFolders } = workspace
     if (!workspaceFolders || workspaceFolders.length === 0) {
@@ -68,18 +56,11 @@ export class Config {
     return workspaceFolders[0].uri.fsPath
   }
 
-  private setDvcCliPath = async (): Promise<void> => {
-    const path = await findCliPath(this.workspaceRoot, this.dvcPath)
-    if (path) {
-      this.dvcCliPath = path
-    }
-  }
-
   public get dvcPath(): string {
-    return <string>workspace.getConfiguration().get('dvc.dvcPath')
+    return workspace.getConfiguration().get('dvc.dvcPath', '')
   }
 
-  private setDvcPath(path = 'dvc'): Thenable<void> {
+  private setDvcPath(path?: string): Thenable<void> {
     return workspace.getConfiguration().update('dvc.dvcPath', path)
   }
 
@@ -88,35 +69,54 @@ export class Config {
 
     dvcPathStatusBarItem.tooltip = 'Current DVC path.'
     dvcPathStatusBarItem.command = 'dvc.selectDvcPath'
+    dvcPathStatusBarItem.text = this.dvcPath
     dvcPathStatusBarItem.show()
     return dvcPathStatusBarItem
   }
 
-  public selectDvcPath = async (): Promise<string | undefined> => {
+  public selectDvcPath = async (): Promise<void> => {
     const result = await window.showQuickPick(
-      [{ label: 'default' }, { label: 'custom' }],
-      { placeHolder: 'Please choose...' }
+      [
+        {
+          label: 'Default',
+          description: 'Use Python Extension virtual environment if available',
+          picked: true,
+          value: undefined
+        },
+        {
+          label: 'Find',
+          description: 'Browse the filesystem for a DVC executable',
+          value: async () => {
+            const result = await window.showOpenDialog({
+              title: 'Select a DVC executable'
+            })
+            if (result) {
+              const [input] = result
+              const { fsPath } = input
+              this.setDvcPath(fsPath)
+              return fsPath
+            } else {
+              return undefined
+            }
+          }
+        }
+      ],
+      {
+        placeHolder: 'Please choose...'
+      }
     )
     if (result) {
-      if (result.label === 'default') {
-        await this.setDvcPath()
-        return this.dvcPath
-      }
-      if (result.label === 'custom') {
-        const path = await window.showInputBox({
-          prompt: 'Enter a custom DVC path...'
-        })
-        await this.setDvcPath(path)
-        return this.dvcPath
+      const { value } = result
+      if (typeof value === 'function') {
+        await value()
+      } else {
+        this.setDvcPath(value)
       }
     }
   }
 
   private findDvcRoots = async () => {
-    const rootPaths = await findDvcRootPaths(
-      this.workspaceRoot,
-      this.dvcCliPath
-    )
+    const rootPaths = await findDvcRootPaths(this.workspaceRoot, this.dvcPath)
     this.dvcRootPaths = rootPaths
   }
 
@@ -147,14 +147,10 @@ export class Config {
     )
 
     this.dispose.track(
-      this.onDidChange(async () => {
-        this.setDvcPaths()
+      this.onDidChange(() => {
+        this.updateDvcPathStatusBarItem()
+        this.findDvcRoots()
       })
     )
-
-    const dvcOverridePath = process.env.DVCPATH
-    this.setDvcPathsOnActivation(dvcOverridePath).then(() =>
-      this._initialized.resolve()
-    )
   }
 }

extension/src/IntegratedTerminal.ts

@@ -1,13 +1,8 @@
-import { Extension, extensions, Terminal, window, workspace } from 'vscode'
+import { Terminal, window, workspace } from 'vscode'
 import { getRunExperimentCommand } from './cli/commands'
+import { getReadyPythonExtension } from './extensions/python'
 import { delay } from './util'
 
-interface PythonExtensionAPI {
-  ready: Thenable<void>
-}
-
-type PythonExtension = Extension<PythonExtensionAPI>
-
 // Static class that creates and holds a reference to an integrated terminal and can run commands in it.
 export class IntegratedTerminal {
   static termName = 'DVC'
@@ -37,12 +32,12 @@ export class IntegratedTerminal {
   private static initializeInstance = async (): Promise<void> => {
     IntegratedTerminal.deleteReferenceOnClose()
 
-    const pythonExtension = extensions.getExtension('ms-python.python')
+    const pythonExtension = await getReadyPythonExtension()
     if (
       pythonExtension &&
       workspace.getConfiguration().get('python.terminal.activateEnvironment')
     ) {
-      return IntegratedTerminal.createPythonInstance(pythonExtension)
+      return IntegratedTerminal.createInstance(5000)
     }
 
     return IntegratedTerminal.createInstance(2000)
@@ -59,18 +54,6 @@ export class IntegratedTerminal {
     })
   }
 
-  private static createPythonInstance = async (
-    pythonExtension: PythonExtension
-  ): Promise<void> => {
-    if (!pythonExtension.isActive) {
-      await IntegratedTerminal.waitForReadyPromise(pythonExtension)
-    }
-    return IntegratedTerminal.createInstance(5000)
-  }
-
-  private static waitForReadyPromise = async (extension: PythonExtension) =>
-    (await extension.activate()).ready
-
   private static createInstance = async (ms: number): Promise<void> => {
     IntegratedTerminal.instance = window.createTerminal({
       name: IntegratedTerminal.termName

extension/src/cli/index.ts

@@ -4,7 +4,7 @@ import { execCommand } from './reader'
 
 export const add = async (options: {
   fsPath: string
-  cliPath: string
+  cliPath: string | undefined
 }): Promise<string> => {
   const { fsPath, cliPath } = options
 

extension/src/cli/reader.test.ts

@@ -5,21 +5,48 @@ import {
   initializeDirectory,
   checkoutRecursive,
   getRoot,
-  listDvcOnlyRecursive
+  listDvcOnlyRecursive,
+  getDvcInvocation
 } from './reader'
 import { execPromise } from '../util'
 import complexExperimentsOutput from '../webviews/experiments/complex-output-example.json'
 import { join, resolve } from 'path'
+import { getPythonExecutionDetails } from '../extensions/python'
 
 jest.mock('fs')
 jest.mock('../util')
+jest.mock('../extensions/python')
 
 const mockedExecPromise = mocked(execPromise)
+const mockedGetPythonExecutionDetails = mocked(getPythonExecutionDetails)
 
 beforeEach(() => {
   jest.resetAllMocks()
 })
 
+describe('getDvcInvocation', () => {
+  it('should utilize an interpreter path from the Python extension by default', async () => {
+    const testPythonBin = '/custom/path/to/python'
+    mockedGetPythonExecutionDetails.mockResolvedValue([testPythonBin])
+    expect(await getDvcInvocation({ cliPath: '', cwd: './' })).toEqual(
+      `${testPythonBin} -m dvc`
+    )
+  })
+
+  it('should ignore a path from the Python extension when cliPath is defined', async () => {
+    const testPythonBin = '/custom/path/to/python'
+    mockedGetPythonExecutionDetails.mockResolvedValue(['/wrong/python/bin'])
+    expect(
+      await getDvcInvocation({ cliPath: testPythonBin, cwd: './' })
+    ).toEqual(testPythonBin)
+  })
+
+  it('should return a simple dvc call when no Python extension is present', async () => {
+    mockedGetPythonExecutionDetails.mockResolvedValue(undefined)
+    expect(await getDvcInvocation({ cliPath: '', cwd: './' })).toEqual('dvc')
+  })
+})
+
 describe('getExperiments', () => {
   it('should match a snapshot when parsed', async () => {
     const cwd = resolve()

extension/src/cli/reader.ts

@@ -1,19 +1,29 @@
 import { Commands } from './commands'
 import { execPromise } from '../util'
 import { ExperimentsRepoJSONOutput } from '../webviews/experiments/contract'
+import { getPythonExecutionDetails } from '../extensions/python'
 
 interface ReaderOptions {
-  cliPath: string
+  cliPath: string | undefined
   cwd: string
 }
 
-export const execCommand = (
+export const getDvcInvocation = async (options: ReaderOptions) => {
+  const { cliPath } = options
+  if (cliPath) {
+    return cliPath
+  }
+  const executionDetails = await getPythonExecutionDetails()
+  return executionDetails ? `${executionDetails.join(' ')} -m dvc` : 'dvc'
+}
+
+export const execCommand = async (
   options: ReaderOptions,
   command: string
 ): Promise<{ stdout: string; stderr: string }> => {
-  const { cliPath, cwd } = options
-
-  return execPromise(`${cliPath} ${command}`, {
+  const { cwd } = options
+  const fullCommandString = `${await getDvcInvocation(options)} ${command}`
+  return execPromise(fullCommandString, {
     cwd
   })
 }