Add support to select env folders as interpreterPaths

Kartik Raj · Kartik Raj · commit 71c441ce5c6e · 2022-02-04T00:43:19.000+05:30
diff --git a/src/client/common/process/pythonEnvironment.ts b/src/client/common/process/pythonEnvironment.ts
@@ -133,7 +133,6 @@ export function createPythonEnv(
 
 export async function createCondaEnv(
     condaInfo: CondaEnvironmentInfo,
-    pythonPath: string,
     // These are used to generate the deps.
     procs: IProcessService,
     fs: IFileSystem,
@@ -150,7 +149,14 @@ export async function createCondaEnv(
         (file, args, opts) => procs.exec(file, args, opts),
         (command, opts) => procs.shellExec(command, opts),
     );
-    return new PythonEnvironment(pythonPath, deps);
+    const interpreterPath = await conda?.getInterpreterPathForEnvironment({
+        name: condaInfo.name,
+        prefix: condaInfo.path,
+    });
+    if (!interpreterPath) {
+        return undefined;
+    }
+    return new PythonEnvironment(interpreterPath, deps);
 }
 
 export function createWindowsStoreEnv(
diff --git a/src/client/common/process/pythonExecutionFactory.ts b/src/client/common/process/pythonExecutionFactory.ts
@@ -131,7 +131,7 @@ export class PythonExecutionFactory implements IPythonExecutionFactory {
         if (!condaEnvironment) {
             return undefined;
         }
-        const env = await createCondaEnv(condaEnvironment, pythonPath, processService, this.fileSystem);
+        const env = await createCondaEnv(condaEnvironment, processService, this.fileSystem);
         if (!env) {
             return undefined;
         }
diff --git a/src/client/interpreter/configuration/interpreterSelector/commands/setInterpreter.ts b/src/client/interpreter/configuration/interpreterSelector/commands/setInterpreter.ts
@@ -155,7 +155,8 @@ export class SetInterpreterCommand extends BaseInterpreterSelectorCommand {
             return this._enterOrBrowseInterpreterPath(input, state, suggestions);
         } else {
             sendTelemetryEvent(EventName.SELECT_INTERPRETER_SELECTED, undefined, { action: 'selected' });
-            state.path = (selection as IInterpreterQuickPickItem).path;
+            const { interpreter } = selection as IInterpreterQuickPickItem;
+            state.path = interpreter.envType === EnvironmentType.Conda ? interpreter.envPath : interpreter.path;
         }
 
         return undefined;
diff --git a/src/client/pythonEnvironments/base/locators/composite/envsCollectionCache.ts b/src/client/pythonEnvironments/base/locators/composite/envsCollectionCache.ts
@@ -4,7 +4,7 @@
 import { Event } from 'vscode';
 import { traceInfo } from '../../../../logging';
 import { reportInterpretersChanged } from '../../../../proposedApi';
-import { pathExists } from '../../../common/externalDependencies';
+import { arePathsSame, pathExists } from '../../../common/externalDependencies';
 import { PythonEnvInfo } from '../../info';
 import { areSameEnv } from '../../info/env';
 import {
@@ -124,8 +124,12 @@ export class PythonEnvInfoCache extends PythonEnvsWatcher<PythonEnvCollectionCha
         }
     }
 
-    public getCompleteInfo(executablePath: string): PythonEnvInfo | undefined {
-        const env = this.envs.find((e) => areSameEnv(e, executablePath));
+    public getCompleteInfo(path: string): PythonEnvInfo | undefined {
+        let env = this.envs.find((e) => arePathsSame(e.location, path));
+        if (env?.hasCompleteInfo) {
+            return env;
+        }
+        env = this.envs.find((e) => areSameEnv(e, path));
         return env?.hasCompleteInfo ? env : undefined;
     }
 
diff --git a/src/client/pythonEnvironments/base/locators/lowLevel/condaLocator.ts b/src/client/pythonEnvironments/base/locators/lowLevel/condaLocator.ts
@@ -3,12 +3,8 @@
 import '../../../../common/extensions';
 import { PythonEnvKind } from '../../info';
 import { BasicEnvInfo, IPythonEnvsIterator, Locator } from '../../locator';
-import { getInterpreterPathFromDir } from '../../../common/commonUtils';
-import { Conda, CONDA_ACTIVATION_TIMEOUT } from '../../../common/environmentManagers/conda';
+import { Conda } from '../../../common/environmentManagers/conda';
 import { traceError, traceVerbose } from '../../../../logging';
-import { shellExecute } from '../../../common/externalDependencies';
-import { getExecutable } from '../../../../common/process/internal/python';
-import { buildPythonExecInfo, copyPythonExecInfo } from '../../../exec';
 
 export class CondaEnvironmentLocator extends Locator<BasicEnvInfo> {
     // eslint-disable-next-line class-methods-use-this
@@ -21,38 +17,15 @@ export class CondaEnvironmentLocator extends Locator<BasicEnvInfo> {
         traceVerbose(`Searching for conda environments using ${conda.command}`);
 
         const envs = await conda.getEnvList();
-        for (const { name, prefix } of envs) {
-            let executablePath = await getInterpreterPathFromDir(prefix);
+        for (const env of envs) {
+            const executablePath = await conda.getInterpreterPathForEnvironment(env);
             if (executablePath !== undefined) {
                 traceVerbose(`Found conda environment: ${executablePath}`);
                 try {
-                    yield { kind: PythonEnvKind.Conda, executablePath, envPath: prefix };
+                    yield { kind: PythonEnvKind.Conda, executablePath, envPath: env.prefix };
                 } catch (ex) {
                     traceError(`Failed to process environment: ${executablePath}`, ex);
                 }
-            } else {
-                const runArgs = await conda.getRunPythonArgs({ name, prefix });
-                if (runArgs) {
-                    try {
-                        const [args, parse] = getExecutable();
-                        const python = buildPythonExecInfo(runArgs);
-                        const info = copyPythonExecInfo(python, args);
-                        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 shellExecute(quoted, { timeout: CONDA_ACTIVATION_TIMEOUT });
-                        executablePath = parse(result.stdout);
-                        if (executablePath !== '') {
-                            traceVerbose(`Found conda environment: ${JSON.stringify({ name, prefix })}`);
-                            yield { kind: PythonEnvKind.Conda, executablePath, envPath: prefix };
-                        }
-                    } catch (ex) {
-                        traceError(`Failed to process environment: ${JSON.stringify({ name, prefix })}`, ex);
-                    }
-                }
             }
         }
     }
diff --git a/src/client/pythonEnvironments/common/environmentManagers/conda.ts b/src/client/pythonEnvironments/common/environmentManagers/conda.ts
@@ -2,7 +2,15 @@ import * as fsapi from 'fs-extra';
 import * as path from 'path';
 import { lt, parse, SemVer } from 'semver';
 import { getEnvironmentVariable, getOSType, getUserHomeDir, OSType } from '../../../common/utils/platform';
-import { arePathsSame, exec, getPythonSetting, isParentPath, pathExists, readFile } from '../externalDependencies';
+import {
+    arePathsSame,
+    exec,
+    getPythonSetting,
+    isParentPath,
+    pathExists,
+    readFile,
+    shellExecute,
+} from '../externalDependencies';
 
 import { PythonVersion, UNKNOWN_PYTHON_VERSION } from '../../base/info';
 import { parseVersion } from '../../base/info/pythonVersion';
@@ -13,6 +21,8 @@ import { cache } from '../../../common/utils/decorators';
 import { isTestExecution } from '../../../common/constants';
 import { traceError, traceVerbose } from '../../../logging';
 import { OUTPUT_MARKER_SCRIPT } from '../../../common/process/internal/scripts';
+import { getExecutable } from '../../../common/process/internal/python';
+import { buildPythonExecInfo, copyPythonExecInfo } from '../../exec';
 
 export const AnacondaCompanyName = 'Anaconda, Inc.';
 
@@ -82,7 +92,7 @@ export async function parseCondaInfo(
         .then((interpreters) => interpreters.map((interpreter) => interpreter!));
 }
 
-function getCondaMetaPaths(interpreterPath: string): string[] {
+export function getCondaMetaPaths(interpreterPath: string): string[] {
     const condaMetaDir = 'conda-meta';
 
     // Check if the conda-meta directory is in the same directory as the interpreter.
@@ -200,6 +210,15 @@ export async function getPythonVersionFromConda(interpreterPath: string): Promis
     return UNKNOWN_PYTHON_VERSION;
 }
 
+/**
+ * Return the interpreter's filename for the given environment.
+ */
+function getInterpreterPath(condaEnvironmentPath: string): string {
+    // where to find the Python binary within a conda env.
+    const relativePath = getOSType() === OSType.Windows ? 'python.exe' : path.join('bin', 'python');
+    return path.join(condaEnvironmentPath, relativePath);
+}
+
 // Minimum version number of conda required to be able to use 'conda run' with '--no-capture-output' flag.
 export const CONDA_RUN_VERSION = '4.9.0';
 export const CONDA_ACTIVATION_TIMEOUT = 45000;
@@ -405,6 +424,33 @@ export class Conda {
         return envList.find((e) => isParentPath(executable, e.prefix));
     }
 
+    @cache(-1, true)
+    public async getInterpreterPathForEnvironment(condaEnv: CondaEnvInfo): Promise<string | undefined> {
+        let executablePath = getInterpreterPath(condaEnv.prefix);
+        if (executablePath) {
+            return executablePath;
+        }
+        const runArgs = await this.getRunPythonArgs(condaEnv);
+        if (runArgs) {
+            try {
+                const [args, parseOutput] = getExecutable();
+                const python = buildPythonExecInfo(runArgs);
+                const info = copyPythonExecInfo(python, args);
+                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 shellExecute(quoted, { timeout: CONDA_ACTIVATION_TIMEOUT });
+                executablePath = parseOutput(result.stdout);
+            } catch (ex) {
+                traceError(`Failed to process environment: ${JSON.stringify(condaEnv)}`, ex);
+            }
+        }
+        return executablePath;
+    }
+
     public async getRunPythonArgs(env: CondaEnvInfo): Promise<string[] | undefined> {
         const condaVersion = await this.getCondaVersion();
         if (condaVersion && lt(condaVersion, CONDA_RUN_VERSION)) {

Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ export class PythonExecutionFactory implements IPythonExecutionFactory {`
`131`	`131`	`if (!condaEnvironment) {`
`132`	`132`	`return undefined;`
`133`	`133`	`}`
`134`		`- const env = await createCondaEnv(condaEnvironment, pythonPath, processService, this.fileSystem);`
	`134`	`+ const env = await createCondaEnv(condaEnvironment, processService, this.fileSystem);`
`135`	`135`	`if (!env) {`
`136`	`136`	`return undefined;`
`137`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,8 @@ export class SetInterpreterCommand extends BaseInterpreterSelectorCommand {`
`155`	`155`	`return this._enterOrBrowseInterpreterPath(input, state, suggestions);`
`156`	`156`	`} else {`
`157`	`157`	`sendTelemetryEvent(EventName.SELECT_INTERPRETER_SELECTED, undefined, { action: 'selected' });`
`158`		`- state.path = (selection as IInterpreterQuickPickItem).path;`
	`158`	`+ const { interpreter } = selection as IInterpreterQuickPickItem;`
	`159`	`+ state.path = interpreter.envType === EnvironmentType.Conda ? interpreter.envPath : interpreter.path;`
`159`	`160`	`}`
`160`	`161`
`161`	`162`	`return undefined;`