Add type info which can be used to differentiate Pyenv global installs from Pyenv virtualenvs

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

@@ -16,6 +16,7 @@ import {
     PythonEnvInfo,
     PythonEnvKind,
     PythonEnvSource,
+    PythonEnvType,
     PythonReleaseLevel,
     PythonVersion,
     virtualEnvKinds,
@@ -40,6 +41,7 @@ export function buildEnvInfo(init?: {
     display?: string;
     sysPrefix?: string;
     searchLocation?: Uri;
+    type?: PythonEnvType;
 }): PythonEnvInfo {
     const env: PythonEnvInfo = {
         name: init?.name ?? '',
@@ -103,6 +105,7 @@ function updateEnv(
         location?: string;
         version?: PythonVersion;
         searchLocation?: Uri;
+        type?: PythonEnvType;
     },
 ): void {
     if (updates.kind !== undefined) {
@@ -120,6 +123,9 @@ function updateEnv(
     if (updates.searchLocation !== undefined) {
         env.searchLocation = updates.searchLocation;
     }
+    if (updates.type !== undefined) {
+        env.type = updates.type;
+    }
 }
 
 /**

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

@@ -26,6 +26,11 @@ export enum PythonEnvKind {
     OtherVirtual = 'virt-other',
 }
 
+export enum PythonEnvType {
+    Conda = 'Conda',
+    Virtual = 'Virtual',
+}
+
 export interface EnvPathType {
     /**
      * Path to environment folder or path to interpreter that uniquely identifies an environment.
@@ -105,6 +110,7 @@ export enum PythonEnvSource {
 type PythonEnvBaseInfo = {
     id?: string;
     kind: PythonEnvKind;
+    type?: PythonEnvType;
     executable: PythonExecutableInfo;
     // One of (name, location) must be non-empty.
     name: string;

src/client/pythonEnvironments/base/locators/composite/resolverUtils.ts

@@ -4,7 +4,14 @@
 import * as path from 'path';
 import { Uri } from 'vscode';
 import { uniq } from 'lodash';
-import { PythonEnvInfo, PythonEnvKind, PythonEnvSource, UNKNOWN_PYTHON_VERSION, virtualEnvKinds } from '../../info';
+import {
+    PythonEnvInfo,
+    PythonEnvKind,
+    PythonEnvSource,
+    PythonEnvType,
+    UNKNOWN_PYTHON_VERSION,
+    virtualEnvKinds,
+} from '../../info';
 import {
     buildEnvInfo,
     comparePythonVersionSpecificity,
@@ -26,6 +33,7 @@ import { getRegistryInterpreters, getRegistryInterpretersSync } from '../../../c
 import { BasicEnvInfo } from '../../locator';
 import { parseVersionFromExecutable } from '../../info/executable';
 import { traceError, traceWarn } from '../../../../logging';
+import { isVirtualEnvironment } from '../../../common/environmentManagers/simplevirtualenvs';
 
 function getResolvers(): Map<PythonEnvKind, (env: BasicEnvInfo, useCache?: boolean) => Promise<PythonEnvInfo>> {
     const resolvers = new Map<PythonEnvKind, (_: BasicEnvInfo, useCache?: boolean) => Promise<PythonEnvInfo>>();
@@ -62,9 +70,26 @@ export async function resolveBasicEnv(env: BasicEnvInfo, useCache = false): Prom
     const { ctime, mtime } = await getFileInfo(resolvedEnv.executable.filename);
     resolvedEnv.executable.ctime = ctime;
     resolvedEnv.executable.mtime = mtime;
+    const type = await getEnvType(resolvedEnv);
+    if (type) {
+        resolvedEnv.type = type;
+    }
     return resolvedEnv;
 }
 
+async function getEnvType(env: PythonEnvInfo) {
+    if (env.type) {
+        return env.type;
+    }
+    if (await isVirtualEnvironment(env.executable.filename)) {
+        return PythonEnvType.Virtual;
+    }
+    if (await isCondaEnvironment(env.executable.filename)) {
+        return PythonEnvType.Conda;
+    }
+    return undefined;
+}
+
 function getSearchLocation(env: PythonEnvInfo): Uri | undefined {
     const folders = getWorkspaceFolders();
     const isRootedEnv = folders.some((f) => isParentPath(env.executable.filename, f) || isParentPath(env.location, f));
@@ -131,6 +156,7 @@ async function resolveSimpleEnv(env: BasicEnvInfo): Promise<PythonEnvInfo> {
         kind,
         version: await getPythonVersionFromPath(executablePath),
         executable: executablePath,
+        type: PythonEnvType.Virtual,
     });
     const location = getEnvironmentDirFromPath(executablePath);
     envInfo.location = location;
@@ -161,6 +187,7 @@ async function resolveCondaEnv(env: BasicEnvInfo, useCache?: boolean): Promise<P
                 location: prefix,
                 source: [],
                 version: executable ? await getPythonVersionFromPath(executable) : undefined,
+                type: PythonEnvType.Conda,
             });
             if (name) {
                 info.name = name;
@@ -175,7 +202,9 @@ async function resolveCondaEnv(env: BasicEnvInfo, useCache?: boolean): Promise<P
     );
     // Environment could still be valid, resolve as a simple env.
     env.kind = PythonEnvKind.Unknown;
-    return resolveSimpleEnv(env);
+    const envInfo = await resolveSimpleEnv(env);
+    envInfo.type = PythonEnvType.Conda;
+    return envInfo;
 }
 
 async function resolvePyenvEnv(env: BasicEnvInfo): Promise<PythonEnvInfo> {

src/client/pythonEnvironments/common/environmentManagers/simplevirtualenvs.ts

@@ -30,6 +30,15 @@ function getPyvenvConfigPathsFrom(interpreterPath: string): string[] {
     return [venvPath1, venvPath2];
 }
 
+/**
+ * Checks if the given interpreter is a virtual environment.
+ * @param {string} interpreterPath: Absolute path to the python interpreter.
+ * @returns {boolean} : Returns true if the interpreter belongs to a venv environment.
+ */
+export async function isVirtualEnvironment(interpreterPath: string): Promise<boolean> {
+    return isVenvEnvironment(interpreterPath);
+}
+
 /**
  * Checks if the given interpreter belongs to a venv based environment.
  * @param {string} interpreterPath: Absolute path to the python interpreter.

src/test/pythonEnvironments/base/locators/composite/envsResolver.unit.test.ts

@@ -13,6 +13,7 @@ import * as platformApis from '../../../../../client/common/utils/platform';
 import {
     PythonEnvInfo,
     PythonEnvKind,
+    PythonEnvType,
     PythonVersion,
     UNKNOWN_PYTHON_VERSION,
 } from '../../../../../client/pythonEnvironments/base/info';
@@ -66,6 +67,9 @@ suite('Python envs locator - Environments Resolver', () => {
         updatedEnv.arch = Architecture.x64;
         updatedEnv.display = expectedDisplay;
         updatedEnv.detailedDisplayName = expectedDisplay;
+        if (env.kind === PythonEnvKind.Conda) {
+            env.type = PythonEnvType.Conda;
+        }
         return updatedEnv;
     }
 
@@ -76,6 +80,7 @@ suite('Python envs locator - Environments Resolver', () => {
         name = '',
         location = '',
         display: string | undefined = undefined,
+        type?: PythonEnvType,
     ): PythonEnvInfo {
         return {
             name,
@@ -94,6 +99,7 @@ suite('Python envs locator - Environments Resolver', () => {
             distro: { org: '' },
             searchLocation: Uri.file(location),
             source: [],
+            type,
         };
     }
     suite('iterEnvs()', () => {
@@ -128,6 +134,7 @@ suite('Python envs locator - Environments Resolver', () => {
                 'win1',
                 path.join(testVirtualHomeDir, '.venvs', 'win1'),
                 "Python ('win1': venv)",
+                PythonEnvType.Virtual,
             );
             const envsReturnedByParentLocator = [env1];
             const parentLocator = new SimpleLocator<BasicEnvInfo>(envsReturnedByParentLocator);
@@ -151,6 +158,8 @@ suite('Python envs locator - Environments Resolver', () => {
                 undefined,
                 'win1',
                 path.join(testVirtualHomeDir, '.venvs', 'win1'),
+                undefined,
+                PythonEnvType.Virtual,
             );
             const envsReturnedByParentLocator = [env1];
             const parentLocator = new SimpleLocator<BasicEnvInfo>(envsReturnedByParentLocator);
@@ -206,6 +215,8 @@ suite('Python envs locator - Environments Resolver', () => {
                 undefined,
                 'win1',
                 path.join(testVirtualHomeDir, '.venvs', 'win1'),
+                undefined,
+                PythonEnvType.Virtual,
             );
             const envsReturnedByParentLocator = [env];
             const didUpdate = new EventEmitter<PythonEnvUpdatedEvent<BasicEnvInfo> | ProgressNotificationEvent>();
@@ -355,6 +366,8 @@ suite('Python envs locator - Environments Resolver', () => {
                 undefined,
                 'win1',
                 path.join(testVirtualHomeDir, '.venvs', 'win1'),
+                undefined,
+                PythonEnvType.Virtual,
             );
             const parentLocator = new SimpleLocator([]);
             const resolver = new PythonEnvsResolver(parentLocator, envInfoService);

src/test/pythonEnvironments/base/locators/composite/resolverUtils.unit.test.ts

@@ -11,6 +11,7 @@ import {
     PythonEnvInfo,
     PythonEnvKind,
     PythonEnvSource,
+    PythonEnvType,
     PythonVersion,
     UNKNOWN_PYTHON_VERSION,
 } from '../../../../../client/pythonEnvironments/base/info';
@@ -76,6 +77,7 @@ suite('Resolver Utils', () => {
                 },
                 source: [],
                 org: 'miniconda3',
+                type: PythonEnvType.Conda,
             });
             envInfo.location = path.join(testPyenvVersionsDir, 'miniconda3-4.7.12');
             envInfo.name = 'base';
@@ -209,6 +211,7 @@ suite('Resolver Utils', () => {
                 version: UNKNOWN_PYTHON_VERSION,
                 fileInfo: undefined,
                 name: 'base',
+                type: PythonEnvType.Conda,
             });
             setEnvDisplayString(info);
             return info;
@@ -237,6 +240,7 @@ suite('Resolver Utils', () => {
                 searchLocation: undefined,
                 source: [],
             };
+            info.type = PythonEnvType.Conda;
             setEnvDisplayString(info);
             return info;
         }
@@ -333,6 +337,7 @@ suite('Resolver Utils', () => {
                 distro: { org: '' },
                 searchLocation: Uri.file(location),
                 source: [],
+                type: PythonEnvType.Virtual,
             };
             setEnvDisplayString(info);
             return info;
@@ -623,6 +628,7 @@ suite('Resolver Utils', () => {
                 org: 'ContinuumAnalytics', // Provided by registry
                 name: 'conda3',
                 source: [PythonEnvSource.WindowsRegistry],
+                type: PythonEnvType.Conda,
             });
             setEnvDisplayString(expected);
             expected.distro.defaultDisplayName = 'Anaconda py38_4.8.3';