Revert environment manager work

Author: edvilme

README.md

@@ -65,13 +65,6 @@ The following environment managers are supported out of the box:
 
 Environment managers are responsible for specifying which package manager will be used by default to install and manage Python packages within the environment (`venv` uses `pip` by default). This ensures that packages are managed consistently according to the preferred tools and settings of the chosen environment manager.
 
-The built-in `venv` environment manager uses separate standard-library venv and uv creation
-backends. Creation automatically uses uv when the existing uv policy allows it and uv is available
-to the creation scope; otherwise it uses `python -m venv`. Backend execution errors are reported
-without retrying through the other backend. Both kinds of virtual environment retain the same
-`ms-python.python:venv` manager identity, discovery, selection, and removal behavior. Backend
-selection does not hide existing environments when uv availability or `python-envs.alwaysUseUv` changes.
-
 ### Package Management
 
 The extension also provides an interface to install and uninstall Python packages, and provides APIs for extension developers to contribute package managers of their choice.
@@ -95,6 +88,7 @@ manager explicitly always uses uv, independently of that setting. The uv package
 uv from PATH, a current-session installation, or the requesting trusted workspace's `.pyprojectx/main/uv`
 (`uv.exe` on Windows). If uv is unavailable, it reports an error rather than falling back to pip.
 Scoped requests use the project to discover uv even when the target environment is outside the workspace.
+Explicit uv selection also retains this scope for project-tree package operations.
 Package mutations invalidate both built-in backends' cached inventory for the target environment,
 so switching between pip and uv does not reuse a snapshot from before the mutation.
 

src/managers/builtin/environmentCreation.ts

@@ -8,9 +8,7 @@ import { BuiltInPackageManager } from './builtInPackageManager';
 import { PipPackageManager } from './pipPackageManager';
 import { SysPythonManager } from './sysPythonManager';
 import { UvPackageManager } from './uvPackageManager';
-import { VenvEnvironmentManager } from './venvEnvironmentManager';
-import { BuiltInEnvironmentManager } from './builtInEnvironmentManager';
-import { UvEnvironmentManager } from './uvEnvironmentManager';
+import { VenvManager } from './venvManager';
 
 export async function registerSystemPythonFeatures(
     nativeFinder: NativePythonFinder,
@@ -19,14 +17,7 @@ export async function registerSystemPythonFeatures(
     envManager: SysPythonManager,
 ): Promise<void> {
     const api: PythonEnvironmentApi = await getPythonApi();
-    const venvManager = new BuiltInEnvironmentManager(
-        nativeFinder,
-        api,
-        envManager,
-        log,
-        new VenvEnvironmentManager(),
-        new UvEnvironmentManager(),
-    );
+    const venvManager = new VenvManager(nativeFinder, api, envManager, log);
     const uvPackageManager = new UvPackageManager(api, log, venvManager);
     const pipPackageManager = new PipPackageManager(api, log, venvManager);
     const pkgManager = new BuiltInPackageManager(pipPackageManager, uvPackageManager);

src/managers/builtin/main.ts

@@ -49,7 +49,7 @@ import {
     PipVersionCommand,
 } from './commands/index';
 import { getWorkspacePackagesToInstall } from './pipUtils';
-import { BuiltInEnvironmentManager } from './builtInEnvironmentManager';
+import { VenvManager } from './venvManager';
 
 /** Manages packages using only the selected environment's pip installation. */
 export class PipPackageManager implements PackageManager, Disposable {
@@ -98,7 +98,7 @@ export class PipPackageManager implements PackageManager, Disposable {
     constructor(
         private readonly api: PythonEnvironmentApi,
         public readonly log: LogOutputChannel,
-        private readonly venv: BuiltInEnvironmentManager,
+        private readonly venv: VenvManager,
     ) {}
     readonly name = 'pip';
     readonly displayName = 'Pip';

src/managers/builtin/pipPackageManager.ts

@@ -25,11 +25,12 @@ import {
     PackageManagerCapability,
     PythonEnvironment,
     PythonEnvironmentApi,
+    PythonProject,
 } from '../../api';
 import { showErrorMessageWithLogs } from '../../common/errors/utils';
 import { PythonVersion } from '../../common/pythonVersion';
 import { showErrorMessage, withProgress } from '../../common/window.apis';
-import { PackageToolSupport, pythonToolSupport, throwIfCancelled } from '../../internal/pythonToolSupport';
+import { PackageToolSupport, pythonToolSupport, throwIfCancelled, ToolPackageManager } from '../../internal/pythonToolSupport';
 import { CommandConstructorOptions } from '../base/commands/index';
 import { updatePackagesAndNotify } from '../common/packageChanges';
 import { parsePackageSpecs } from '../common/packageUtils';
@@ -43,7 +44,7 @@ import {
 } from './commands/index';
 import { getUvExecutable } from './helpers';
 import { getWorkspacePackagesToInstall } from './pipUtils';
-import { BuiltInEnvironmentManager } from './builtInEnvironmentManager';
+import { VenvManager } from './venvManager';
 
 /** Manages packages using only uv, without requiring pip in the environment. */
 export class UvPackageManager implements PackageManager, Disposable {
@@ -79,9 +80,36 @@ export class UvPackageManager implements PackageManager, Disposable {
     constructor(
         private readonly api: PythonEnvironmentApi,
         public readonly log: LogOutputChannel,
-        private readonly venv: BuiltInEnvironmentManager,
+        private readonly venv: VenvManager,
     ) {}
 
+    /**
+     * Binds UI operations to a project while retaining this manager's cache and registered identity.
+     * @param project Project whose workspace-local uv executable should be used.
+     */
+    createForProject(project: PythonProject): ToolPackageManager {
+        return this.withScope(project.uri);
+    }
+
+    private withScope(scope: Uri): ToolPackageManager {
+        return {
+            name: this.name,
+            displayName: this.displayName,
+            description: this.description,
+            tooltip: this.tooltip,
+            iconPath: this.iconPath,
+            log: this.log,
+            capabilities: this.capabilities,
+            [pythonToolSupport]: this[pythonToolSupport],
+            manage: (environment, options) => this.manage(environment, options, undefined, scope),
+            refresh: (environment) => this.refresh(environment, scope),
+            getPackages: (environment, options) => this.getPackages(environment, options, scope),
+            getVersion: (environment) => this.getVersion(environment, scope),
+            getPackageAvailableVersions: (environment, name) => this.getPackageAvailableVersions(environment, name, scope),
+            getDirectPackageNames: (environment) => this.getDirectPackageNames(environment, scope),
+        };
+    }
+
     /**
      * Evicts cached inventory and prevents older reads from restoring it.
      * @param environment Environment whose inventory may have changed.
@@ -192,7 +220,7 @@ export class UvPackageManager implements PackageManager, Disposable {
                     }
                 }
                 await updatePackagesAndNotify(
-                    this,
+                    scope ? this.withScope(scope) : this,
                     environment,
                     before,
                     (changes) => this._onDidChangePackages.fire({ environment, manager: this, changes }),
@@ -232,13 +260,13 @@ export class UvPackageManager implements PackageManager, Disposable {
     }
 
     /** Refreshes cached packages and emits changes for the target environment. */
-    async refresh(environment: PythonEnvironment): Promise<void> {
+    async refresh(environment: PythonEnvironment, scope?: Uri): Promise<void> {
         await withProgress(
             { location: ProgressLocation.Window, title: l10n.t('Refreshing packages') },
             async () => {
                 const revision = this.packageCacheRevisions.get(environment.envId.id);
                 const packages = await updatePackagesAndNotify(
-                    this, environment, this.packages.get(environment.envId.id),
+                    scope ? this.withScope(scope) : this, environment, this.packages.get(environment.envId.id),
                     (changes) => this._onDidChangePackages.fire({ environment, manager: this, changes }),
                 );
                 if (packages !== undefined && revision === this.packageCacheRevisions.get(environment.envId.id)) {
@@ -249,9 +277,13 @@ export class UvPackageManager implements PackageManager, Disposable {
     }
 
     /** Lists installed packages, using the cache unless options request a fresh snapshot. */
-    async getPackages(environment: PythonEnvironment, options?: GetPackagesOptions): Promise<Package[] | undefined> {
+    async getPackages(
+        environment: PythonEnvironment,
+        options?: GetPackagesOptions,
+        scope?: Uri,
+    ): Promise<Package[] | undefined> {
         if (options?.skipCache || !this.packages.has(environment.envId.id)) {
-            return this.fetchPackages(environment);
+            return this.fetchPackages(environment, true, undefined, scope);
         }
         return this.packages.get(environment.envId.id);
     }
@@ -292,31 +324,35 @@ export class UvPackageManager implements PackageManager, Disposable {
     }
 
     /** Returns the uv version, logging failures when it cannot be determined. */
-    async getVersion(environment: PythonEnvironment): Promise<Pep440Version | undefined> {
+    async getVersion(environment: PythonEnvironment, scope?: Uri): Promise<Pep440Version | undefined> {
         try {
-            return await new UvVersionCommand(await this.getCommandOptions(environment)).execute();
+            return await new UvVersionCommand(await this.getCommandOptions(environment, { cwd: scope?.fsPath })).execute();
         } catch (error) {
             this.log.error('Error determining uv version', error);
             return undefined;
         }
     }
 
     /** Lists compatible versions of packageName, newest first, without querying the environment's pip. */
-    async getPackageAvailableVersions(environment: PythonEnvironment, packageName: string): Promise<Pep440Version[]> {
+    async getPackageAvailableVersions(
+        environment: PythonEnvironment,
+        packageName: string,
+        scope?: Uri,
+    ): Promise<Pep440Version[]> {
         const pythonVersion = environment.version
             ? PythonVersion.tryParse(environment.version)?.toReleaseString()
             : undefined;
         if (!pythonVersion) {
             throw new Error(`Python version is unavailable for environment: ${environment.envId.id}`);
         }
-        const command = new UvAvailableVersionsCommand(await this.getCommandOptions(environment));
+        const command = new UvAvailableVersionsCommand(await this.getCommandOptions(environment, { cwd: scope?.fsPath }));
         const versions = await command.execute({ packageName, pythonVersion });
         return versions.sort((a, b) => compare(b.public, a.public));
     }
 
     /** Returns dependency-root package names, which need not reflect explicit user install intent. */
-    async getDirectPackageNames(environment: PythonEnvironment): Promise<Set<string> | undefined> {
-        return new UvListDirectNamesCommand(await this.getCommandOptions(environment)).execute();
+    async getDirectPackageNames(environment: PythonEnvironment, scope?: Uri): Promise<Set<string> | undefined> {
+        return new UvListDirectNamesCommand(await this.getCommandOptions(environment, { cwd: scope?.fsPath })).execute();
     }
 
     /** Releases package-change listeners and cached packages. */

src/managers/builtin/uvEnvironmentManager.ts

@@ -50,11 +50,8 @@ import { findParentIfFile } from '../../features/envCommands';
 import { getProjectFsPathForScope, tryFastPathGet } from '../common/fastPath';
 import { NativePythonFinder } from '../common/nativePythonFinder';
 import { getLatest, shortenVersionString, sortEnvironments } from '../common/utils';
-import { getDefaultGlobalPython, resolveSystemPythonEnvironmentPath } from './utils';
-import { EnvironmentBackendSelector, EnvironmentCreationBackend, selectEnvironmentBackend } from './environmentCreation';
-import { VenvEnvironmentManager } from './venvEnvironmentManager';
-import { UvEnvironmentManager } from './uvEnvironmentManager';
 import { promptInstallPython } from './pythonInstaller';
+import { getDefaultGlobalPython, resolveSystemPythonEnvironmentPath } from './utils';
 import {
     clearVenvCache,
     CreateEnvironmentResult,
@@ -72,7 +69,7 @@ import {
     setVenvForWorkspaces,
 } from './venvUtils';
 
-export class BuiltInEnvironmentManager implements EnvironmentManager {
+export class VenvManager implements EnvironmentManager {
     readonly capabilities: Capabilities<EnvironmentManagerCapability> = {
         [EnvironmentCapability.List]: supportedCapability,
         [EnvironmentCapability.Resolve]: supportedCapability,
@@ -107,8 +104,6 @@ export class BuiltInEnvironmentManager implements EnvironmentManager {
         private readonly api: PythonEnvironmentApi,
         private readonly baseManager: EnvironmentManager,
         public readonly log: LogOutputChannel,
-        private readonly venv: EnvironmentCreationBackend = new VenvEnvironmentManager(),
-        private readonly uv: EnvironmentCreationBackend = new UvEnvironmentManager(),
     ) {
         this.name = 'venv';
         this.displayName = 'venv';
@@ -120,9 +115,6 @@ export class BuiltInEnvironmentManager implements EnvironmentManager {
         this.iconPath = new ThemeIcon('python');
     }
 
-    private readonly selectCreationBackend: EnvironmentBackendSelector = (base, root, token) =>
-        selectEnvironmentBackend(this.log, base, root, token, this.venv, this.uv);
-
     private _initialized: Deferred<void> | undefined;
     private discovery: Deferred<void> | undefined;
     private initializationError: unknown;
@@ -226,7 +218,6 @@ export class BuiltInEnvironmentManager implements EnvironmentManager {
                 scope,
                 undefined,
                 operation,
-                this.selectCreationBackend,
             );
             if (!result?.environment) {
                 throw new PythonToolError(
@@ -354,23 +345,14 @@ export class BuiltInEnvironmentManager implements EnvironmentManager {
                         this.globalEnv,
                         venvRoot,
                         options?.additionalPackages,
-                        undefined,
-                        this.selectCreationBackend,
                     );
                 }
             } else {
                 // If quickCreate is not set that means the user triggered this method from
                 // environment manager View, by selecting the venv manager.
-                result = await createPythonVenv(
-                    this.nativeFinder,
-                    this.api,
-                    this.log,
-                    this,
-                    globals,
-                    venvRoot,
-                    { showQuickAndCustomOptions: options?.quickCreate === undefined },
-                    this.selectCreationBackend,
-                );
+                result = await createPythonVenv(this.nativeFinder, this.api, this.log, this, globals, venvRoot, {
+                    showQuickAndCustomOptions: options?.quickCreate === undefined,
+                });
             }
 
             if (result?.environment) {