Add support for base interpreter paths (#18441)

* Add support for shell-like interpreter paths

* Add explanation in comment

Author: Kartik Raj

src/client/common/process/pythonEnvironment.ts

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+import * as path from 'path';
 import { traceError, traceInfo } from '../../logging';
 import { Conda, CondaEnvironmentInfo } from '../../pythonEnvironments/common/environmentManagers/conda';
 import { buildPythonExecInfo, PythonExecInfo } from '../../pythonEnvironments/exec';
@@ -56,7 +57,7 @@ class PythonEnvironment implements IPythonEnvironment {
             return result;
         }
         const python = this.getExecutionInfo();
-        const promise = getExecutablePath(python, this.deps.exec);
+        const promise = getExecutablePath(python, this.deps.shellExec);
         this.cachedExecutablePath.set(this.pythonPath, promise);
         return promise;
     }
@@ -106,8 +107,19 @@ function createDeps(
     shellExec: (command: string, options?: ShellOptions) => Promise<ExecutionResult<string>>,
 ) {
     return {
-        getPythonArgv: (python: string) => pythonArgv || [python],
-        getObservablePythonArgv: (python: string) => observablePythonArgv || [python],
+        getPythonArgv: (python: string) => {
+            if (path.basename(python) === python) {
+                // Say when python is `py -3.8` or `conda run python`
+                pythonArgv = python.split(' ');
+            }
+            return pythonArgv || [python];
+        },
+        getObservablePythonArgv: (python: string) => {
+            if (path.basename(python) === python) {
+                observablePythonArgv = python.split(' ');
+            }
+            return observablePythonArgv || [python];
+        },
         isValidExecutable,
         exec: async (cmd: string, args: string[]) => exec(cmd, args, { throwOnStdErr: true }),
         shellExec: async (text: string, timeout: number) => shellExec(text, { timeout }),

src/client/pythonEnvironments/info/executable.ts

@@ -1,25 +1,30 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { getExecutable as getPythonExecutableCommand } from '../../common/process/internal/python';
+import { getExecutable } from '../../common/process/internal/python';
+import { ExecutionResult } from '../../common/process/types';
 import { copyPythonExecInfo, PythonExecInfo } from '../exec';
 
-type ExecResult = {
-    stdout: string;
-};
-type ExecFunc = (command: string, args: string[]) => Promise<ExecResult>;
+type ShellExecFunc = (command: string, timeout: number) => Promise<ExecutionResult<string>>;
 
 /**
  * Find the filename for the corresponding Python executable.
  *
  * Effectively, we look up `sys.executable`.
  *
  * @param python - the information to use when running Python
- * @param exec - the function to use to run Python
+ * @param shellExec - the function to use to run Python
  */
-export async function getExecutablePath(python: PythonExecInfo, exec: ExecFunc): Promise<string> {
-    const [args, parse] = getPythonExecutableCommand();
+export async function getExecutablePath(
+    python: PythonExecInfo,
+    shellExec: ShellExecFunc,
+    timeout?: number,
+): Promise<string> {
+    const [args, parse] = getExecutable();
     const info = copyPythonExecInfo(python, args);
-    const result = await exec(info.command, info.args);
-    return parse(result.stdout);
+    const argv = [info.command, ...info.args];
+    // Concat these together to make a set of quoted strings
+    const quoted = argv.reduce((p, c) => (p ? `${p} ${c.toCommandArgument()}` : `${c.toCommandArgument()}`), '');
+    const result = await shellExec(quoted, timeout ?? 15000);
+    return parse(result.stdout.trim());
 }

src/test/common/process/pythonEnvironment.unit.test.ts

@@ -192,9 +192,8 @@ suite('PythonEnvironment', () => {
     test('getExecutablePath should not return pythonPath if pythonPath is not a file', async () => {
         const executablePath = 'path/to/dummy/executable';
         fileSystem.setup((f) => f.pathExists(pythonPath)).returns(() => Promise.resolve(false));
-        const argv = ['-c', 'import sys;print(sys.executable)'];
         processService
-            .setup((p) => p.exec(pythonPath, argv, { throwOnStdErr: true }))
+            .setup((p) => p.shellExec(`${pythonPath} -c "import sys;print(sys.executable)"`, TypeMoq.It.isAny()))
             .returns(() => Promise.resolve({ stdout: executablePath }));
         const env = createPythonEnv(pythonPath, processService.object, fileSystem.object);
 
@@ -206,9 +205,8 @@ suite('PythonEnvironment', () => {
     test('getExecutablePath should throw if the result of exec() writes to stderr', async () => {
         const stderr = 'bar';
         fileSystem.setup((f) => f.pathExists(pythonPath)).returns(() => Promise.resolve(false));
-        const argv = ['-c', 'import sys;print(sys.executable)'];
         processService
-            .setup((p) => p.exec(pythonPath, argv, { throwOnStdErr: true }))
+            .setup((p) => p.shellExec(`${pythonPath} -c "import sys;print(sys.executable)"`, TypeMoq.It.isAny()))
             .returns(() => Promise.reject(new StdErrError(stderr)));
         const env = createPythonEnv(pythonPath, processService.object, fileSystem.object);
 

src/test/pythonEnvironments/info/executable.unit.test.ts

@@ -2,16 +2,13 @@
 // Licensed under the MIT License.
 
 import { expect } from 'chai';
-import { IMock, Mock, MockBehavior } from 'typemoq';
-import { StdErrError } from '../../../client/common/process/types';
+import { IMock, Mock, MockBehavior, It } from 'typemoq';
+import { ExecutionResult, StdErrError } from '../../../client/common/process/types';
 import { buildPythonExecInfo } from '../../../client/pythonEnvironments/exec';
 import { getExecutablePath } from '../../../client/pythonEnvironments/info/executable';
 
-type ExecResult = {
-    stdout: string;
-};
 interface IDeps {
-    exec(command: string, args: string[]): Promise<ExecResult>;
+    shellExec(command: string, timeout: number): Promise<ExecutionResult<string>>;
 }
 
 suite('getExecutablePath()', () => {
@@ -24,11 +21,10 @@ suite('getExecutablePath()', () => {
 
     test('should get the value by running python', async () => {
         const expected = 'path/to/dummy/executable';
-        const argv = ['-c', 'import sys;print(sys.executable)'];
-        deps.setup((d) => d.exec(python.command, argv))
+        deps.setup((d) => d.shellExec(`${python.command} -c "import sys;print(sys.executable)"`, It.isAny()))
             // Return the expected value.
             .returns(() => Promise.resolve({ stdout: expected }));
-        const exec = async (c: string, a: string[]) => deps.object.exec(c, a);
+        const exec = async (c: string, a: number) => deps.object.shellExec(c, a);
 
         const result = await getExecutablePath(python, exec);
 
@@ -38,15 +34,14 @@ suite('getExecutablePath()', () => {
 
     test('should throw if exec() fails', async () => {
         const stderr = 'oops';
-        const argv = ['-c', 'import sys;print(sys.executable)'];
-        deps.setup((d) => d.exec(python.command, argv))
+        deps.setup((d) => d.shellExec(`${python.command} -c "import sys;print(sys.executable)"`, It.isAny()))
             // Throw an error.
             .returns(() => Promise.reject(new StdErrError(stderr)));
-        const exec = async (c: string, a: string[]) => deps.object.exec(c, a);
+        const exec = async (c: string, a: number) => deps.object.shellExec(c, a);
 
-        const result = getExecutablePath(python, exec);
+        const promise = getExecutablePath(python, exec);
 
-        expect(result).to.eventually.be.rejectedWith(stderr);
+        expect(promise).to.eventually.be.rejectedWith(stderr);
         deps.verifyAll();
     });
 });