fix: improve no-python conda handling

Author: karthiknadig

src/common/localize.ts

@@ -13,6 +13,7 @@ export namespace Common {
     export const yes = l10n.t('Yes');
     export const no = l10n.t('No');
     export const quickCreate = l10n.t('Quick Create');
+    export const installPython = l10n.t('Install Python');
 }
 
 export namespace Interpreter {
@@ -139,6 +140,11 @@ export namespace CondaStrings {
 
     export const quickCreateCondaNoEnvRoot = l10n.t('No conda environment root found');
     export const quickCreateCondaNoName = l10n.t('Could not generate a name for env');
+
+    export const condaMissingPython = l10n.t('No Python found in the selected conda environment');
+    export const condaMissingPythonNoFix = l10n.t(
+        'No Python found in the selected conda environment. Please select another environment or install Python manually.',
+    );
 }
 
 export namespace ProjectCreatorString {

src/managers/conda/condaEnvManager.ts

@@ -18,7 +18,12 @@ import {
     ResolveEnvironmentContext,
     SetEnvironmentScope,
 } from '../../api';
+import { CondaStrings } from '../../common/localize';
+import { createDeferred, Deferred } from '../../common/utils/deferred';
+import { showErrorMessage, withProgress } from '../../common/window.apis';
+import { NativePythonFinder } from '../common/nativePythonFinder';
 import {
+    checkForNoPythonCondaEnvironment,
     clearCondaCache,
     createCondaEnvironment,
     deleteCondaEnvironment,
@@ -33,15 +38,10 @@ import {
     setCondaForWorkspace,
     setCondaForWorkspaces,
 } from './condaUtils';
-import { NativePythonFinder } from '../common/nativePythonFinder';
-import { createDeferred, Deferred } from '../../common/utils/deferred';
-import { showErrorMessage, withProgress } from '../../common/window.apis';
-import { CondaStrings } from '../../common/localize';
 
 export class CondaEnvManager implements EnvironmentManager, Disposable {
     private collection: PythonEnvironment[] = [];
     private fsPathToEnv: Map<string, PythonEnvironment> = new Map();
-    private disposablesMap: Map<string, Disposable> = new Map();
     private globalEnv: PythonEnvironment | undefined;
 
     private readonly _onDidChangeEnvironment = new EventEmitter<DidChangeEnvironmentEventArgs>();
@@ -70,7 +70,8 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
     iconPath?: IconPath;
 
     public dispose() {
-        this.disposablesMap.forEach((d) => d.dispose());
+        this.collection = [];
+        this.fsPathToEnv.clear();
     }
 
     private _initialized: Deferred<void> | undefined;
@@ -166,20 +167,7 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
                 );
             }
             if (result) {
-                this.disposablesMap.set(
-                    result.envId.id,
-                    new Disposable(() => {
-                        if (result) {
-                            this.collection = this.collection.filter((env) => env.envId.id !== result?.envId.id);
-                            Array.from(this.fsPathToEnv.entries())
-                                .filter(([, env]) => env.envId.id === result?.envId.id)
-                                .forEach(([uri]) => this.fsPathToEnv.delete(uri));
-                            this.disposablesMap.delete(result.envId.id);
-                        }
-                    }),
-                );
-                this.collection.push(result);
-                this._onDidChangeEnvironments.fire([{ kind: EnvironmentChangeKind.add, environment: result }]);
+                this.addEnvironment(result);
             }
 
             return result;
@@ -189,12 +177,28 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
         }
     }
 
+    private addEnvironment(environment: PythonEnvironment, raiseEvent: boolean = true): void {
+        this.collection.push(environment);
+        if (raiseEvent) {
+            this._onDidChangeEnvironments.fire([{ kind: EnvironmentChangeKind.add, environment: environment }]);
+        }
+    }
+
+    private removeEnvironment(environment: PythonEnvironment, raiseEvent: boolean = true): void {
+        this.collection = this.collection.filter((env) => env.envId.id !== environment.envId.id);
+        Array.from(this.fsPathToEnv.entries())
+            .filter(([, env]) => env.envId.id === environment.envId.id)
+            .forEach(([uri]) => this.fsPathToEnv.delete(uri));
+        if (raiseEvent) {
+            this._onDidChangeEnvironments.fire([{ kind: EnvironmentChangeKind.remove, environment }]);
+        }
+    }
+
     async remove(context: PythonEnvironment): Promise<void> {
         try {
             const projects = this.getProjectsForEnvironment(context);
+            this.removeEnvironment(context, false);
             await deleteCondaEnvironment(context, this.log);
-            this.disposablesMap.get(context.envId.id)?.dispose();
-
             setImmediate(() => {
                 this._onDidChangeEnvironments.fire([{ kind: EnvironmentChangeKind.remove, environment: context }]);
                 projects.forEach((project) =>
@@ -207,9 +211,6 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
     }
     async refresh(context: RefreshEnvironmentsScope): Promise<void> {
         if (context === undefined) {
-            this.disposablesMap.forEach((d) => d.dispose());
-            this.disposablesMap.clear();
-
             await withProgress(
                 {
                     location: ProgressLocation.Window,
@@ -252,18 +253,22 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
     }
 
     async set(scope: SetEnvironmentScope, environment?: PythonEnvironment | undefined): Promise<void> {
+        const checkedEnv = environment
+            ? await checkForNoPythonCondaEnvironment(this.nativeFinder, this, environment, this.api, this.log)
+            : undefined;
+
         if (scope === undefined) {
-            await setCondaForGlobal(environment?.environmentPath?.fsPath);
+            await setCondaForGlobal(checkedEnv?.environmentPath?.fsPath);
         } else if (scope instanceof Uri) {
             const folder = this.api.getPythonProject(scope);
             const fsPath = folder?.uri?.fsPath ?? scope.fsPath;
             if (fsPath) {
-                if (environment) {
-                    this.fsPathToEnv.set(fsPath, environment);
+                if (checkedEnv) {
+                    this.fsPathToEnv.set(fsPath, checkedEnv);
                 } else {
                     this.fsPathToEnv.delete(fsPath);
                 }
-                await setCondaForWorkspace(fsPath, environment?.environmentPath.fsPath);
+                await setCondaForWorkspace(fsPath, checkedEnv?.environmentPath.fsPath);
             }
         } else if (Array.isArray(scope) && scope.every((u) => u instanceof Uri)) {
             const projects: PythonProject[] = [];
@@ -278,25 +283,38 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
             const before: Map<string, PythonEnvironment | undefined> = new Map();
             projects.forEach((p) => {
                 before.set(p.uri.fsPath, this.fsPathToEnv.get(p.uri.fsPath));
-                if (environment) {
-                    this.fsPathToEnv.set(p.uri.fsPath, environment);
+                if (checkedEnv) {
+                    this.fsPathToEnv.set(p.uri.fsPath, checkedEnv);
                 } else {
                     this.fsPathToEnv.delete(p.uri.fsPath);
                 }
             });
 
             await setCondaForWorkspaces(
                 projects.map((p) => p.uri.fsPath),
-                environment?.environmentPath.fsPath,
+                checkedEnv?.environmentPath.fsPath,
             );
 
             projects.forEach((p) => {
                 const b = before.get(p.uri.fsPath);
-                if (b?.envId.id !== environment?.envId.id) {
-                    this._onDidChangeEnvironment.fire({ uri: p.uri, old: b, new: environment });
+                if (b?.envId.id !== checkedEnv?.envId.id) {
+                    this._onDidChangeEnvironment.fire({ uri: p.uri, old: b, new: checkedEnv });
                 }
             });
         }
+
+        if (environment && checkedEnv && checkedEnv.envId.id !== environment.envId.id) {
+            this.removeEnvironment(environment, false);
+            this.addEnvironment(checkedEnv, false);
+            setImmediate(() => {
+                this._onDidChangeEnvironments.fire([
+                    { kind: EnvironmentChangeKind.remove, environment },
+                    { kind: EnvironmentChangeKind.add, environment: checkedEnv },
+                ]);
+                const uri = scope ? (scope instanceof Uri ? scope : scope[0]) : undefined;
+                this._onDidChangeEnvironment.fire({ uri, old: environment, new: checkedEnv });
+            });
+        }
     }
 
     async resolve(context: ResolveEnvironmentContext): Promise<PythonEnvironment | undefined> {

src/managers/conda/condaPackageManager.ts

@@ -17,10 +17,10 @@ import {
     PythonEnvironment,
     PythonEnvironmentApi,
 } from '../../api';
-import { getCommonCondaPackagesToInstall, managePackages, refreshPackages } from './condaUtils';
-import { withProgress } from '../../common/window.apis';
 import { showErrorMessageWithLogs } from '../../common/errors/utils';
 import { CondaStrings } from '../../common/localize';
+import { withProgress } from '../../common/window.apis';
+import { getCommonCondaPackagesToInstall, managePackages, refreshPackages } from './condaUtils';
 
 function getChanges(before: Package[], after: Package[]): { kind: PackageChangeKind; pkg: Package }[] {
     const changes: { kind: PackageChangeKind; pkg: Package }[] = [];
@@ -79,7 +79,7 @@ export class CondaPackageManager implements PackageManager, Disposable {
             async (_progress, token) => {
                 try {
                     const before = this.packages.get(environment.envId.id) ?? [];
-                    const after = await managePackages(environment, manageOptions, this.api, this, token);
+                    const after = await managePackages(environment, manageOptions, this.api, this, token, this.log);
                     const changes = getChanges(before, after);
                     this.packages.set(environment.envId.id, after);
                     this._onDidChangePackages.fire({ environment: environment, manager: this, changes });