Use UV installer for package installation as fallback (#16821)

* Use UV installer for package installation as fallback

* Updates

* Remove unwanted tests

* Fix tests

* Fix win tests

* Fix win tests

Author: DonJayamanne

src/platform/interpreter/installer/channelManager.node.ts

@@ -44,8 +44,10 @@ export class InstallationChannelManager implements IInstallationChannelManager {
         // group by priority and pick supported from the highest priority
         installers.sort((a, b) => b.priority - a.priority);
         let currentPri = installers[0].priority;
-        let uvInstaller: IModuleInstaller | undefined;
-        for (const mi of installers) {
+        // Check uv and Python ext installer only if there are no other options, hence exclude them initially.
+        for (const mi of installers.filter(
+            (m) => m.type !== ModuleInstallerType.UV && m.type !== ModuleInstallerType.PythonExt
+        )) {
             if (mi.priority !== currentPri) {
                 if (supportedInstallers.length > 0) {
                     break; // return highest priority supported installers
@@ -54,16 +56,25 @@ export class InstallationChannelManager implements IInstallationChannelManager {
                 currentPri = mi.priority;
             }
             if (await mi.isSupported(interpreter)) {
-                if (mi.type === ModuleInstallerType.UV) {
-                    uvInstaller = mi;
-                } else {
-                    supportedInstallers.push(mi);
-                }
+                supportedInstallers.push(mi);
             }
         }
-        return supportedInstallers.length === 0 && uvInstaller
-            ? [uvInstaller] // If no supported installers, but UV is available, return it.
-            : supportedInstallers; // Otherwise return the supported installers.
+
+        if (supportedInstallers.length > 0) {
+            return supportedInstallers; // Return the highest priority supported installers.
+        }
+
+        const pythonExtInstaller = installers.find((m) => m.type === ModuleInstallerType.PythonExt);
+        const uvInstaller = installers.find((m) => m.type === ModuleInstallerType.UV);
+
+        if (pythonExtInstaller && (await pythonExtInstaller.isSupported(interpreter))) {
+            return [pythonExtInstaller]; // If PythonExt is supported, return it.
+        }
+        if (uvInstaller && (await uvInstaller.isSupported(interpreter))) {
+            return [uvInstaller]; // If UV is supported, return it.
+        }
+
+        return []; // No supported installers found.
     }
 
     public async showNoInstallersMessage(interpreter: PythonEnvironment): Promise<void> {

src/platform/interpreter/installer/pythonEnvsApiInstaller.node.ts

@@ -34,11 +34,11 @@ export class PythonEnvsApiInstaller extends ModuleInstaller {
     }
 
     public get type(): ModuleInstallerType {
-        return ModuleInstallerType.UV;
+        return ModuleInstallerType.PythonExt;
     }
 
     public get displayName() {
-        return 'Python Environment API';
+        return 'Python Environment Installer';
     }
 
     public get priority(): number {

src/platform/interpreter/installer/pythonEnvsApiInstaller.unit.test.ts

@@ -51,16 +51,8 @@ suite('Python Envs API Installer', () => {
 
     teardown(() => disposables.clear());
 
-    test('Should have correct name', () => {
-        assert.equal(installer.name, 'PythonEnvsApi');
-    });
-
-    test('Should have correct display name', () => {
-        assert.equal(installer.displayName, 'Python Environment API');
-    });
-
     test('Should have correct type', () => {
-        assert.equal(installer.type, ModuleInstallerType.UV);
+        assert.equal(installer.type, ModuleInstallerType.PythonExt);
     });
 
     test('Should have high priority', () => {

src/platform/interpreter/installer/types.ts

@@ -44,7 +44,8 @@ export enum ModuleInstallerType {
     Pip = 'Pip',
     Poetry = 'Poetry',
     Pipenv = 'Pipenv',
-    UV = 'UV'
+    UV = 'UV',
+    PythonExt = 'PythonExt'
 }
 
 export enum ProductType {

src/platform/interpreter/installer/uvInstaller.node.ts

@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { inject, injectable } from 'inversify';
+import { IServiceContainer } from '../../ioc/types';
+import { ExecutionInstallArgs, ModuleInstaller } from './moduleInstaller.node';
+import { IProcessServiceFactory } from '../../common/process/types.node';
+import { ModuleInstallerType, ModuleInstallFlags } from './types';
+import { PythonEnvironment } from '../../pythonEnvironments/info';
+import { Environment } from '@vscode/python-extension';
+import { getInterpreterInfo } from '../helpers';
+
+/**
+ * Installer that uses the UV to manage packages.
+ */
+@injectable()
+export class UvInstaller extends ModuleInstaller {
+    private isInstalledPromise: Promise<boolean>;
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(
+        @inject(IServiceContainer) serviceContainer: IServiceContainer,
+        @inject(IProcessServiceFactory) private readonly processServiceFactory: IProcessServiceFactory
+    ) {
+        super(serviceContainer);
+    }
+
+    public get name(): string {
+        return 'UvInstaller';
+    }
+
+    public get type(): ModuleInstallerType {
+        return ModuleInstallerType.UV;
+    }
+
+    public get displayName() {
+        return 'UV Installer';
+    }
+
+    public get priority(): number {
+        return 200;
+    }
+
+    public async isSupported(interpreter: PythonEnvironment | Environment): Promise<boolean> {
+        const env = await getInterpreterInfo(interpreter);
+        if (!env) {
+            return false;
+        }
+        if (this.isInstalledPromise) {
+            return this.isInstalledPromise;
+        }
+        this.isInstalledPromise = this.isUvInstalled();
+        return this.isInstalledPromise;
+    }
+
+    protected async getExecutionArgs(
+        moduleName: string,
+        interpreter: PythonEnvironment | Environment,
+        flags?: ModuleInstallFlags
+    ): Promise<ExecutionInstallArgs> {
+        const env = await getInterpreterInfo(interpreter);
+        if (!env) {
+            throw new Error('Unable to get interpreter information');
+        }
+        const args = ['pip', 'install'];
+        if (flags && flags & ModuleInstallFlags.upgrade) {
+            args.push('--upgrade');
+        }
+        args.push('--python', env.executable.uri?.fsPath || env.path, moduleName);
+        return {
+            exe: 'uv',
+            args
+        };
+    }
+
+    private async isUvInstalled(): Promise<boolean> {
+        const processService = await this.processServiceFactory.create(undefined);
+        try {
+            const result = await processService.exec('uv', ['--version'], { throwOnStdErr: true, env: process.env });
+            return !!result.stdout;
+        } catch (error) {
+            return false;
+        }
+    }
+}