Add source field to environment info (#15192)

* Add source field to environment info

* Test fixes

* Change source to enum

* Update code to use PythonEnvSource enum instead of raw strings

* Change source Path enum to PathEnvVar

* Fix tests

* Add API to get interpreters by source

* Fix missed conda source

* Update field comments

* Add source to windows path locator

* Fix tests

Author: karthiknadig

src/client/pythonEnvironments/base/info/env.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { cloneDeep } from 'lodash';
+import { cloneDeep, uniq } from 'lodash';
 import * as path from 'path';
 import { getArchitectureDisplayName } from '../../../common/platform/registry';
 import { normalizeFilename } from '../../../common/utils/filesystem';
@@ -11,7 +11,15 @@ import { getKindDisplayName, getPrioritizedEnvKinds } from './envKind';
 import { parseVersionFromExecutable } from './executable';
 import { areIdenticalVersion, areSimilarVersions, getVersionDisplayString, isVersionEmpty } from './pythonVersion';
 
-import { FileInfo, PythonDistroInfo, PythonEnvInfo, PythonEnvKind, PythonReleaseLevel, PythonVersion } from '.';
+import {
+    FileInfo,
+    PythonDistroInfo,
+    PythonEnvInfo,
+    PythonEnvKind,
+    PythonEnvSource,
+    PythonReleaseLevel,
+    PythonVersion,
+} from '.';
 
 /**
  * Create a new info object with all values empty.
@@ -21,14 +29,17 @@ import { FileInfo, PythonDistroInfo, PythonEnvInfo, PythonEnvKind, PythonRelease
 export function buildEnvInfo(init?: {
     kind?: PythonEnvKind;
     executable?: string;
+    name?: string;
     location?: string;
     version?: PythonVersion;
     org?: string;
     arch?: Architecture;
     fileInfo?: { ctime: number; mtime: number };
+    source?: PythonEnvSource[];
+    defaultDisplayName?: string;
 }): PythonEnvInfo {
     const env = {
-        name: '',
+        name: init?.name ?? '',
         location: '',
         kind: PythonEnvKind.Unknown,
         executable: {
@@ -38,7 +49,7 @@ export function buildEnvInfo(init?: {
             mtime: init?.fileInfo?.mtime ?? -1,
         },
         searchLocation: undefined,
-        defaultDisplayName: undefined,
+        defaultDisplayName: init?.defaultDisplayName,
         version: {
             major: -1,
             minor: -1,
@@ -52,6 +63,7 @@ export function buildEnvInfo(init?: {
         distro: {
             org: init?.org ?? '',
         },
+        source: init?.source ?? [],
     };
     if (init !== undefined) {
         updateEnv(env, init);
@@ -481,6 +493,7 @@ export function mergeEnvironments(target: PythonEnvInfo, other: PythonEnvInfo):
     merged.name = merged.name.length ? merged.name : other.name;
     merged.searchLocation = merged.searchLocation ?? other.searchLocation;
     merged.version = version;
+    merged.source = uniq([...target.source, ...other.source]);
 
     return merged;
 }

src/client/pythonEnvironments/base/info/index.ts

@@ -49,6 +49,37 @@ export type PythonExecutableInfo = FileInfo & {
     sysPrefix: string;
 };
 
+/**
+ * Source types indicating how a particular environment was discovered.
+ *
+ * Notes: This is used in auto-selection to figure out which python to select.
+ * We added this field to support the existing mechanism in the extension to
+ * calculate the auto-select python.
+ */
+export enum PythonEnvSource {
+    /**
+     * Environment was found via PATH env variable
+     */
+    PathEnvVar = 'path env var',
+    /**
+     * Environment was found via conda binary or conda environments file
+     */
+    Conda = 'conda',
+    /**
+     * Environment was found at pyenv default location
+     */
+    Pyenv = 'pyenv',
+    /**
+     * Environment was found in windows registry
+     */
+    WindowsRegistry = 'windows registry',
+    /**
+     * Environment was found using other means
+     */
+    Other = 'other',
+    // If source turns out to be useful we will expand this enum to contain more details sources.
+}
+
 /**
  * The most fundamental information about a Python environment.
  *
@@ -61,6 +92,7 @@ export type PythonExecutableInfo = FileInfo & {
  * @prop executable - info about the env's Python binary
  * @prop name - the env's distro-specific name, if any
  * @prop location - the env's location (on disk), if relevant
+ * @prop source - the locator[s] which found the environment.
  */
 export type PythonEnvBaseInfo = {
     kind: PythonEnvKind;
@@ -72,6 +104,8 @@ export type PythonEnvBaseInfo = {
     // * managed: boolean (if the env is "managed")
     // * parent: PythonEnvBaseInfo (the env from which this one was created)
     // * binDir: string (where env-installed executables are found)
+
+    source: PythonEnvSource[];
 };
 
 /**

src/client/pythonEnvironments/base/locators/lowLevel/windowsKnownPathsLocator.ts

@@ -4,11 +4,12 @@
 // tslint:disable-next-line:no-single-line-block-comment
 /* eslint-disable max-classes-per-file */
 
+import { uniq } from 'lodash';
 import { Event } from 'vscode';
 import { getSearchPathEntries } from '../../../../common/utils/exec';
 import { Disposables, IDisposable } from '../../../../common/utils/resourceLifecycle';
 import { isStandardPythonBinary } from '../../../common/commonUtils';
-import { PythonEnvInfo, PythonEnvKind } from '../../info';
+import { PythonEnvInfo, PythonEnvKind, PythonEnvSource } from '../../info';
 import { ILocator, IPythonEnvsIterator, PythonLocatorQuery } from '../../locator';
 import { Locators } from '../../locators';
 import { getEnvs } from '../../locatorUtils';
@@ -68,16 +69,28 @@ function getDirFilesLocator(
         const envs = await getEnvs(locator.iterEnvs(query));
         for (const env of envs) {
             if (isStandardPythonBinary(env.executable?.filename || '')) {
+                env.source = env.source
+                    ? uniq([...env.source, PythonEnvSource.PathEnvVar])
+                    : [PythonEnvSource.PathEnvVar];
                 yield env;
             }
         }
     }
     async function resolveEnv(env: string | PythonEnvInfo): Promise<PythonEnvInfo | undefined> {
         const executable = typeof env === 'string' ? env : env.executable?.filename || '';
+
         if (!isStandardPythonBinary(executable)) {
             return undefined;
         }
-        return locator.resolveEnv(env);
+        const resolved = await locator.resolveEnv(env);
+        if (resolved) {
+            const source =
+                typeof env === 'string'
+                    ? [PythonEnvSource.PathEnvVar]
+                    : uniq([...env.source, PythonEnvSource.PathEnvVar]);
+            resolved.source = source;
+        }
+        return resolved;
     }
     return {
         iterEnvs,

src/client/pythonEnvironments/base/locators/lowLevel/workspaceVirtualEnvLocator.ts

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+import { uniq } from 'lodash';
 import * as path from 'path';
 import { Uri } from 'vscode';
 import { traceVerbose } from '../../../../common/logger';
@@ -17,7 +18,7 @@ import {
     isVenvEnvironment,
     isVirtualenvEnvironment,
 } from '../../../discovery/locators/services/virtualEnvironmentIdentifier';
-import { PythonEnvInfo, PythonEnvKind } from '../../info';
+import { PythonEnvInfo, PythonEnvKind, PythonEnvSource } from '../../info';
 import { buildEnvInfo } from '../../info/env';
 import { IPythonEnvsIterator } from '../../locator';
 import { FSWatchingLocator } from './fsWatchingLocator';
@@ -56,11 +57,16 @@ async function getVirtualEnvKind(interpreterPath: string): Promise<PythonEnvKind
     return PythonEnvKind.Unknown;
 }
 
-async function buildSimpleVirtualEnvInfo(executablePath: string, kind: PythonEnvKind): Promise<PythonEnvInfo> {
+async function buildSimpleVirtualEnvInfo(
+    executablePath: string,
+    kind: PythonEnvKind,
+    source?: PythonEnvSource[],
+): Promise<PythonEnvInfo> {
     const envInfo = buildEnvInfo({
         kind,
         version: await getPythonVersionFromPath(executablePath),
         executable: executablePath,
+        source: source ?? [PythonEnvSource.Other],
     });
     const location = getEnvironmentDirFromPath(executablePath);
     envInfo.location = location;
@@ -132,12 +138,13 @@ export class WorkspaceVirtualEnvironmentLocator extends FSWatchingLocator {
     // eslint-disable-next-line class-methods-use-this
     protected async doResolveEnv(env: string | PythonEnvInfo): Promise<PythonEnvInfo | undefined> {
         const executablePath = typeof env === 'string' ? env : env.executable.filename;
+        const source = typeof env === 'string' ? [PythonEnvSource.Other] : uniq([PythonEnvSource.Other, ...env.source]);
         if (isParentPath(executablePath, this.root) && (await pathExists(executablePath))) {
             // We should extract the kind here to avoid doing is*Environment()
             // check multiple times. Those checks are file system heavy and
             // we can use the kind to determine this anyway.
             const kind = await getVirtualEnvKind(executablePath);
-            return buildSimpleVirtualEnvInfo(executablePath, kind);
+            return buildSimpleVirtualEnvInfo(executablePath, kind, source);
         }
         return undefined;
     }

src/client/pythonEnvironments/discovery/locators/services/condaLocator.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 import '../../../../common/extensions';
-import { PythonEnvInfo, PythonEnvKind } from '../../../base/info';
+import { PythonEnvInfo, PythonEnvKind, PythonEnvSource } from '../../../base/info';
 import { buildEnvInfo } from '../../../base/info/env';
 import { IPythonEnvsIterator, Locator } from '../../../base/locator';
 import { getInterpreterPathFromDir } from '../../../common/commonUtils';
@@ -48,6 +48,7 @@ export class CondaEnvironmentLocator extends Locator {
                     kind: PythonEnvKind.Conda,
                     org: AnacondaCompanyName,
                     location: prefix,
+                    source: [PythonEnvSource.Conda],
                 });
                 if (name) {
                     info.name = name;

src/client/pythonEnvironments/discovery/locators/services/customVirtualEnvLocator.ts

@@ -6,7 +6,7 @@ import * as path from 'path';
 import { traceVerbose } from '../../../../common/logger';
 import { chain, iterable } from '../../../../common/utils/async';
 import { getUserHomeDir } from '../../../../common/utils/platform';
-import { PythonEnvInfo, PythonEnvKind } from '../../../base/info';
+import { PythonEnvInfo, PythonEnvKind, PythonEnvSource } from '../../../base/info';
 import { buildEnvInfo } from '../../../base/info/env';
 import { IPythonEnvsIterator } from '../../../base/locator';
 import { FSWatchingLocator } from '../../../base/locators/lowLevel/fsWatchingLocator';
@@ -85,6 +85,7 @@ async function buildSimpleVirtualEnvInfo(executablePath: string, kind: PythonEnv
         kind,
         version: await getPythonVersionFromPath(executablePath),
         executable: executablePath,
+        source: [PythonEnvSource.Other],
     });
     const location = getEnvironmentDirFromPath(executablePath);
     envInfo.location = location;

src/client/pythonEnvironments/discovery/locators/services/globalVirtualEnvronmentLocator.ts

@@ -6,7 +6,7 @@ import * as path from 'path';
 import { traceVerbose } from '../../../../common/logger';
 import { chain, iterable } from '../../../../common/utils/async';
 import { getEnvironmentVariable, getOSType, getUserHomeDir, OSType } from '../../../../common/utils/platform';
-import { PythonEnvInfo, PythonEnvKind } from '../../../base/info';
+import { PythonEnvInfo, PythonEnvKind, PythonEnvSource } from '../../../base/info';
 import { buildEnvInfo } from '../../../base/info/env';
 import { IPythonEnvsIterator } from '../../../base/locator';
 import { FSWatchingLocator } from '../../../base/locators/lowLevel/fsWatchingLocator';
@@ -84,6 +84,7 @@ async function buildSimpleVirtualEnvInfo(executablePath: string, kind: PythonEnv
         kind,
         version: await getPythonVersionFromPath(executablePath),
         executable: executablePath,
+        source: [PythonEnvSource.Other],
     });
     const location = getEnvironmentDirFromPath(executablePath);
     envInfo.location = location;

src/client/pythonEnvironments/discovery/locators/services/posixKnownPathsLocator.ts

@@ -6,7 +6,8 @@ import * as path from 'path';
 import { traceError, traceInfo } from '../../../../common/logger';
 
 import { Architecture } from '../../../../common/utils/platform';
-import { PythonEnvInfo, PythonEnvKind, PythonReleaseLevel, PythonVersion } from '../../../base/info';
+import { PythonEnvInfo, PythonEnvKind, PythonEnvSource, PythonReleaseLevel, PythonVersion } from '../../../base/info';
+import { buildEnvInfo } from '../../../base/info/env';
 import { parseVersion } from '../../../base/info/pythonVersion';
 import { IPythonEnvsIterator, Locator } from '../../../base/locator';
 import { getFileInfo, resolveSymbolicLink } from '../../../common/externalDependencies';
@@ -40,20 +41,20 @@ export class PosixKnownPathsLocator extends Locator {
     private kind: PythonEnvKind = PythonEnvKind.OtherGlobal;
 
     public iterEnvs(): IPythonEnvsIterator {
-        const buildEnvInfo = (bin: string) => this.buildEnvInfo(bin);
+        const buildPathEnvInfo = (bin: string) => this.buildPathEnvInfo(bin);
         const iterator = async function* () {
             const exes = await getPythonBinFromKnownPaths();
-            yield* exes.map(buildEnvInfo);
+            yield* exes.map(buildPathEnvInfo);
         };
         return iterator();
     }
 
     public resolveEnv(env: string | PythonEnvInfo): Promise<PythonEnvInfo | undefined> {
         const executablePath = typeof env === 'string' ? env : env.executable.filename;
-        return this.buildEnvInfo(executablePath);
+        return this.buildPathEnvInfo(executablePath);
     }
 
-    private async buildEnvInfo(bin: string): Promise<PythonEnvInfo> {
+    private async buildPathEnvInfo(bin: string): Promise<PythonEnvInfo> {
         let version: PythonVersion;
         try {
             version = parseVersion(path.basename(bin));
@@ -67,18 +68,15 @@ export class PosixKnownPathsLocator extends Locator {
                 sysVersion: undefined,
             };
         }
-        return {
+        return buildEnvInfo({
             name: '',
             location: '',
             kind: this.kind,
-            executable: {
-                filename: bin,
-                sysPrefix: '',
-                ...(await getFileInfo(bin)),
-            },
+            executable: bin,
+            fileInfo: await getFileInfo(bin),
             version,
             arch: Architecture.Unknown,
-            distro: { org: '' },
-        };
+            source: [PythonEnvSource.PathEnvVar],
+        });
     }
 }