Merge branch 'main' into support-quick-create-from-command

Author: eleanorjboyd

README.md

@@ -151,6 +151,8 @@ The Python Environments extension supports shell startup activation for environm
     -   (Windows): `~\Documents\PowerShell\Microsoft.PowerShell_profile.ps1`
 -   **CMD**: `~/.cmdrc/cmd_startup.bat`
 
+If at any time you would like to revert the changes made to the shell's script, you can do so by running `Python Envs: Revert Shell Startup Script Changes` via the Command Palette.
+
 ### CMD
 
 1. Add or update `HKCU\\Software\\Microsoft\\Command Processor` `AutoRun` string value to use a command script.

package.json

@@ -361,7 +361,7 @@
                 {
                     "command": "python-envs.refreshPackages",
                     "group": "inline",
-                    "when": "view == env-managers && viewItem == python-package-root"
+                    "when": "view == env-managers && viewItem =~ /.*pythonEnvironment.*/"
                 },
                 {
                     "command": "python-envs.packages",
@@ -395,7 +395,7 @@
                 {
                     "command": "python-envs.refreshPackages",
                     "group": "inline",
-                    "when": "view == python-projects && viewItem == python-package-root"
+                    "when": "view == python-projects && viewItem == python-env"
                 },
                 {
                     "command": "python-envs.removePythonProject",

package.nls.json

@@ -19,8 +19,8 @@
     "python-envs.copyProjectPath.title": "Copy Project Path",
     "python-envs.create.title": "Create Environment",
     "python-envs.createAny.title": "Create Environment",
-    "python-envs.set.title": "Set Workspace Environment",
-    "python-envs.setEnv.title": "Set As Workspace Environment",
+    "python-envs.set.title": "Set Project Environment",
+    "python-envs.setEnv.title": "Set As Project Environment",
     "python-envs.reset.title": "Reset to Default",
     "python-envs.remove.title": "Delete Environment",
     "python-envs.refreshAllManagers.title": "Refresh All Environment Managers",

src/common/localize.ts

@@ -158,6 +158,12 @@ export namespace PyenvStrings {
     export const pyenvRefreshing = l10n.t('Refreshing Pyenv Python versions');
 }
 
+export namespace PoetryStrings {
+    export const poetryManager = l10n.t('Manages Poetry environments');
+    export const poetryDiscovering = l10n.t('Discovering Poetry environments');
+    export const poetryRefreshing = l10n.t('Refreshing Poetry environments');
+}
+
 export namespace ProjectCreatorString {
     export const addExistingProjects = l10n.t('Add Existing Projects');
     export const autoFindProjects = l10n.t('Auto Find Projects');
@@ -172,7 +178,7 @@ export namespace ProjectCreatorString {
 
 export namespace EnvViewStrings {
     export const selectedGlobalTooltip = l10n.t('This environment is selected for non-workspace files');
-    export const selectedWorkspaceTooltip = l10n.t('This environment is selected for workspace files');
+    export const selectedWorkspaceTooltip = l10n.t('This environment is selected for project files');
 }
 
 export namespace ActivationStrings {

src/extension.ts

@@ -67,6 +67,7 @@ import { EnvironmentManagers, ProjectCreators, PythonProjectManager } from './in
 import { registerSystemPythonFeatures } from './managers/builtin/main';
 import { createNativePythonFinder, NativePythonFinder } from './managers/common/nativePythonFinder';
 import { registerCondaFeatures } from './managers/conda/main';
+import { registerPoetryFeatures } from './managers/poetry/main';
 import { registerPyenvFeatures } from './managers/pyenv/main';
 
 export async function activate(context: ExtensionContext): Promise<PythonEnvironmentApi> {
@@ -155,7 +156,7 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
             await Promise.all(envManagers.managers.map((m) => m.refresh(undefined)));
         }),
         commands.registerCommand('python-envs.refreshPackages', async (item) => {
-            await refreshPackagesCommand(item);
+            await refreshPackagesCommand(item, envManagers);
         }),
         commands.registerCommand('python-envs.create', async (item) => {
             return await createEnvironmentCommand(item, envManagers, projectManager);
@@ -342,6 +343,7 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
             registerSystemPythonFeatures(nativeFinder, context.subscriptions, outputChannel),
             registerCondaFeatures(nativeFinder, context.subscriptions, outputChannel),
             registerPyenvFeatures(nativeFinder, context.subscriptions),
+            registerPoetryFeatures(nativeFinder, context.subscriptions, outputChannel),
             shellStartupVarsMgr.initialize(),
         ]);
 

src/features/envCommands.ts

@@ -3,6 +3,7 @@ import {
     CreateEnvironmentOptions,
     PythonEnvironment,
     PythonEnvironmentApi,
+    PythonProject,
     PythonProjectCreator,
     PythonProjectCreatorOptions,
 } from '../api';
@@ -21,7 +22,7 @@ import {} from '../common/errors/utils';
 import { pickEnvironment } from '../common/pickers/environments';
 import { pickCreator, pickEnvironmentManager, pickPackageManager } from '../common/pickers/managers';
 import { pickProject, pickProjectMany } from '../common/pickers/projects';
-import { activeTextEditor, showErrorMessage } from '../common/window.apis';
+import { activeTextEditor, showErrorMessage, showInformationMessage } from '../common/window.apis';
 import { quoteArgs } from './execution/execUtils';
 import { runAsTask } from './execution/runAsTask';
 import { runInTerminal } from './terminal/runInTerminal';
@@ -30,12 +31,10 @@ import {
     EnvManagerTreeItem,
     EnvTreeItemKind,
     GlobalProjectItem,
-    PackageRootTreeItem,
     PackageTreeItem,
     ProjectEnvironment,
     ProjectItem,
     ProjectPackage,
-    ProjectPackageRootTreeItem,
     PythonEnvTreeItem,
 } from './views/treeViewItems';
 
@@ -48,15 +47,25 @@ export async function refreshManagerCommand(context: unknown): Promise<void> {
     }
 }
 
-export async function refreshPackagesCommand(context: unknown) {
-    if (context instanceof ProjectPackageRootTreeItem) {
-        const view = context as ProjectPackageRootTreeItem;
-        const manager = view.manager;
-        await manager.refresh(view.environment);
-    } else if (context instanceof PackageRootTreeItem) {
-        const view = context as PackageRootTreeItem;
-        const manager = view.manager;
-        await manager.refresh(view.environment);
+export async function refreshPackagesCommand(context: unknown, managers?: EnvironmentManagers): Promise<void> {
+    if (context instanceof ProjectEnvironment) {
+        const view = context as ProjectEnvironment;
+        if (managers) {
+            const pkgManager = managers.getPackageManager(view.parent.project.uri);
+            if (pkgManager) {
+                await pkgManager.refresh(view.environment);
+            }
+        }
+    } else if (context instanceof PythonEnvTreeItem) {
+        const view = context as PythonEnvTreeItem;
+        const envManager =
+            view.parent.kind === EnvTreeItemKind.environmentGroup
+                ? view.parent.parent.manager
+                : view.parent.manager;
+        const pkgManager = managers?.getPackageManager(envManager.preferredPackageManagerId);
+        if (pkgManager) {
+            await pkgManager.refresh(view.environment);
+        }
     } else {
         traceVerbose(`Invalid context for refresh command: ${context}`);
     }
@@ -192,7 +201,8 @@ export async function removeEnvironmentCommand(context: unknown, managers: Envir
 export async function handlePackageUninstall(context: unknown, em: EnvironmentManagers) {
     if (context instanceof PackageTreeItem || context instanceof ProjectPackage) {
         const moduleName = context.pkg.name;
-        const environment = context.parent.environment;
+        const environment = 
+            context instanceof ProjectPackage ? context.parent.environment : context.parent.environment;
         const packageManager = em.getPackageManager(environment);
         await packageManager?.manage(environment, { uninstall: [moduleName], install: [] });
         return;
@@ -212,8 +222,8 @@ export async function setEnvironmentCommand(
             if (projects.length > 0) {
                 const selected = await pickProjectMany(projects);
                 if (selected && selected.length > 0) {
-                    const uris = selected.map((p) => p.uri);
-                    await em.setEnvironments(uris, view.environment);
+                    // Check if the selected environment is already the current one for each project
+                    await setEnvironmentForProjects(selected, context.environment, em);
                 }
             } else {
                 await em.setEnvironments('global', view.environment);
@@ -271,13 +281,47 @@ export async function setEnvironmentCommand(
         });
 
         if (selected) {
-            await em.setEnvironments(uris, selected);
+            // Use the same logic for checking already set environments
+            await setEnvironmentForProjects(projects, selected, em);
         }
     } else {
         traceError(`Invalid context for setting environment command: ${context}`);
         showErrorMessage('Invalid context for setting environment');
     }
 }
+/**
+ * Sets the environment for the given projects, showing a warning for those already set.
+ * @param selectedProjects Array of  PythonProject selected by user
+ * @param environment The environment to set for the projects
+ * @param em The EnvironmentManagers instance
+ */
+async function setEnvironmentForProjects(
+    selectedProjects: PythonProject[],
+    environment: PythonEnvironment,
+    em: EnvironmentManagers,
+) {
+    let alreadySet: PythonProject[] = [];
+    for (const p of selectedProjects) {
+        const currentEnv = await em.getEnvironment(p.uri);
+        if (currentEnv?.envId.id === environment.envId.id) {
+            alreadySet.push(p);
+        }
+    }
+    if (alreadySet.length > 0) {
+        const env = alreadySet.length > 1 ? 'environments' : 'environment';
+        showInformationMessage(
+            `"${environment.name}" is already selected as the ${env} for: ${alreadySet
+                .map((p) => `"${p.name}"`)
+                .join(', ')}`,
+        );
+    }
+    const toSet: PythonProject[] = selectedProjects.filter((p) => !alreadySet.includes(p));
+    const uris = toSet.map((p) => p.uri);
+    if (uris.length === 0) {
+        return;
+    }
+    await em.setEnvironments(uris, environment);
+}
 
 export async function resetEnvironmentCommand(
     context: unknown,

src/features/views/envManagersView.ts

@@ -13,12 +13,10 @@ import {
     EnvTreeItem,
     EnvManagerTreeItem,
     PythonEnvTreeItem,
-    PackageRootTreeItem,
     PackageTreeItem,
     EnvTreeItemKind,
     NoPythonEnvTreeItem,
     EnvInfoTreeItem,
-    PackageRootInfoTreeItem,
     PythonGroupEnvTreeItem,
 } from './treeViewItems';
 import { createSimpleDebounce } from '../../common/utils/debounce';
@@ -31,7 +29,6 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
     >();
     private revealMap = new Map<string, PythonEnvTreeItem>();
     private managerViews = new Map<string, EnvManagerTreeItem>();
-    private packageRoots = new Map<string, PackageRootTreeItem>();
     private selected: Map<string, string> = new Map();
     private disposables: Disposable[] = [];
 
@@ -42,7 +39,6 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
 
         this.disposables.push(
             new Disposable(() => {
-                this.packageRoots.clear();
                 this.revealMap.clear();
                 this.managerViews.clear();
                 this.selected.clear();
@@ -165,32 +161,18 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
             const views: EnvTreeItem[] = [];
 
             if (pkgManager) {
-                const item = new PackageRootTreeItem(parent, pkgManager, environment);
-                this.packageRoots.set(environment.envId.id, item);
-                views.push(item);
+                const packages = await pkgManager.getPackages(environment);
+                if (packages && packages.length > 0) {
+                    views.push(...packages.map((p) => new PackageTreeItem(p, parent, pkgManager)));
+                } else {
+                    views.push(new EnvInfoTreeItem(parent, ProjectViews.noPackages));
+                }
             } else {
                 views.push(new EnvInfoTreeItem(parent, ProjectViews.noPackageManager));
             }
 
             return views;
         }
-
-        if (element.kind === EnvTreeItemKind.packageRoot) {
-            const root = element as PackageRootTreeItem;
-            const manager = root.manager;
-            const environment = root.environment;
-
-            let packages = await manager.getPackages(environment);
-            const views: EnvTreeItem[] = [];
-
-            if (packages) {
-                views.push(...packages.map((p) => new PackageTreeItem(p, root, manager)));
-            } else {
-                views.push(new PackageRootInfoTreeItem(root, ProjectViews.noPackages));
-            }
-
-            return views;
-        }
     }
 
     getParent(element: EnvTreeItem): ProviderResult<EnvTreeItem> {
@@ -219,35 +201,32 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
     }
 
     private onDidChangePackages(args: InternalDidChangePackagesEventArgs) {
-        const pkgRoot = this.packageRoots.get(args.environment.envId.id);
-        if (pkgRoot) {
-            this.fireDataChanged(pkgRoot);
+        const view = Array.from(this.revealMap.values()).find(
+            (v) => v.environment.envId.id === args.environment.envId.id
+        );
+        if (view) {
+            this.fireDataChanged(view);
         }
     }
 
-    private onDidChangePackageManager(args: DidChangePackageManagerEventArgs) {
-        const roots = Array.from(this.packageRoots.values()).filter((r) => r.manager.id === args.manager.id);
-        this.fireDataChanged(roots);
+    private onDidChangePackageManager(_args: DidChangePackageManagerEventArgs) {
+        // Since we removed the packageRoots level, just refresh all environments
+        // This is a simplified approach that isn't as targeted but ensures packages get refreshed
+        this.fireDataChanged(undefined);
     }
 
     public environmentChanged(e: DidChangeEnvironmentEventArgs) {
         const views = [];
         if (e.old) {
             this.selected.delete(e.old.envId.id);
-            let view: EnvTreeItem | undefined = this.packageRoots.get(e.old.envId.id);
-            if (!view) {
-                view = this.managerViews.get(e.old.envId.managerId);
-            }
+            const view: EnvTreeItem | undefined = this.revealMap.get(e.old.envId.id);
             if (view) {
                 views.push(view);
             }
         }
         if (e.new) {
             this.selected.set(e.new.envId.id, e.uri === undefined ? 'global' : e.uri.fsPath);
-            let view: EnvTreeItem | undefined = this.packageRoots.get(e.new.envId.id);
-            if (!view) {
-                view = this.managerViews.get(e.new.envId.managerId);
-            }
+            const view: EnvTreeItem | undefined = this.revealMap.get(e.new.envId.id);
             if (view && !views.includes(view)) {
                 views.push(view);
             }