fix: keep non-uv Pythons as the default global interpreter

Listing uv-managed installations under Global made them candidates for the
default interpreter, so a newer uv build replaced an existing python.org or
Store Python on machines that have both. uv marks its installations
EXTERNALLY-MANAGED (PEP 668), so installing packages into the new default
failed. Prefer installations not managed by uv when choosing the default and
fall back to uv only when nothing else is available.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: karthiknadig

src/managers/builtin/sysPythonManager.ts

@@ -23,7 +23,6 @@ import { normalizePath } from '../../common/utils/pathUtils';
 import { withProgress } from '../../common/window.apis';
 import { getProjectFsPathForScope, tryFastPathGet } from '../common/fastPath';
 import { NativePythonFinder } from '../common/nativePythonFinder';
-import { getLatest } from '../common/utils';
 import {
     clearSystemEnvCache,
     getSystemEnvForGlobal,
@@ -32,7 +31,7 @@ import {
     setSystemEnvForWorkspace,
     setSystemEnvForWorkspaces,
 } from './cache';
-import { refreshPythons, resolveSystemPythonEnvironmentPath } from './utils';
+import { getDefaultGlobalPython, refreshPythons, resolveSystemPythonEnvironmentPath } from './utils';
 import { installPythonWithUv, promptInstallPythonViaUv, selectPythonVersionToInstall } from './uvPythonInstaller';
 
 export class SysPythonManager implements EnvironmentManager {
@@ -176,7 +175,7 @@ export class SysPythonManager implements EnvironmentManager {
 
     async set(scope: SetEnvironmentScope, environment?: PythonEnvironment): Promise<void> {
         if (scope === undefined) {
-            this.globalEnv = environment ?? getLatest(this.collection);
+            this.globalEnv = environment ?? getDefaultGlobalPython(this.collection);
             if (environment) {
                 await setSystemEnvForGlobal(environment.environmentPath.fsPath);
             }
@@ -372,7 +371,7 @@ export class SysPythonManager implements EnvironmentManager {
 
         // If a global environment is still not set, try using the latest environment
         if (!this.globalEnv) {
-            this.globalEnv = getLatest(this.collection);
+            this.globalEnv = getDefaultGlobalPython(this.collection);
         }
 
         // Try to find workspace environments

src/managers/builtin/utils.ts

@@ -14,12 +14,15 @@ import {
     NativePythonEnvironmentKind,
     NativePythonFinder,
 } from '../common/nativePythonFinder';
-import { shortenVersionString, sortEnvironments } from '../common/utils';
+import { getLatest, shortenVersionString, sortEnvironments } from '../common/utils';
 
 const PIXI_EXTENSION_ID = 'renan-r-santos.pixi-code';
 const PIXI_RECOMMEND_DONT_ASK_KEY = 'pixi-extension-recommend-dont-ask';
 let pixiRecommendationShown = false;
 
+// Global environments created for uv-managed Python installations.
+const uvManagedPythons = new WeakSet<PythonEnvironment>();
+
 function asPackageQuickPickItem(name: string, version?: string): QuickPickItem {
     return {
         label: name,
@@ -146,6 +149,19 @@ export async function isUvManagedPythonInstall(env: NativeEnvInfo): Promise<bool
     return !(await fs.pathExists(path.join(env.prefix, 'pyvenv.cfg')));
 }
 
+/**
+ * Returns the global Python to use by default: the newest one, preferring installations that are not
+ * managed by uv. uv marks its installations EXTERNALLY-MANAGED (PEP 668), so installing packages into
+ * them fails; they are used by default only when no other Python is available.
+ *
+ * @param globals Global Python environments.
+ * @returns The default global Python, or `undefined` when there is none.
+ */
+export function getDefaultGlobalPython(globals: PythonEnvironment[]): PythonEnvironment | undefined {
+    const preferred = globals.filter((e) => !e.error && !uvManagedPythons.has(e));
+    return getLatest(preferred.length > 0 ? preferred : globals);
+}
+
 export async function refreshPythons(
     hardRefresh: boolean,
     nativeFinder: NativePythonFinder,
@@ -188,6 +204,9 @@ export async function refreshPythons(
         try {
             const envInfo = getPythonInfo(env, uvManaged);
             const python = api.createPythonEnvironmentItem(envInfo, manager);
+            if (uvManaged) {
+                uvManagedPythons.add(python);
+            }
             collection.push(python);
         } catch (e) {
             log.error((e as Error).message);
@@ -246,8 +265,12 @@ export async function resolveSystemPythonEnvironmentPath(
 
         // This is supposed to handle a python interpreter as long as we know some basic things about it
         if (resolved.executable && resolved.version && resolved.prefix) {
-            const envInfo = getPythonInfo(resolved, await isUvManagedPythonInstall(resolved));
-            return api.createPythonEnvironmentItem(envInfo, manager);
+            const uvManaged = await isUvManagedPythonInstall(resolved);
+            const python = api.createPythonEnvironmentItem(getPythonInfo(resolved, uvManaged), manager);
+            if (uvManaged) {
+                uvManagedPythons.add(python);
+            }
+            return python;
         }
     } catch (ex) {
         traceVerbose(`Failed to resolve env "${fsPath}": ${ex}`);

src/managers/builtin/venvManager.ts

@@ -32,6 +32,7 @@ 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 } from './utils';
 import { promptInstallPythonViaUv } from './uvPythonInstaller';
 import {
     clearVenvCache,
@@ -568,7 +569,7 @@ export class VenvManager implements EnvironmentManager {
 
         // If a global environment is still not set, use latest from globals
         if (!this.globalEnv) {
-            this.globalEnv = getLatest(globals);
+            this.globalEnv = getDefaultGlobalPython(globals);
         }
     }
 

src/test/managers/builtin/uvManagedPythonInstall.unit.test.ts

@@ -8,7 +8,12 @@ import * as path from 'path';
 import * as sinon from 'sinon';
 import { LogOutputChannel, Uri } from 'vscode';
 import { EnvironmentManager, PythonEnvironment, PythonEnvironmentApi, PythonEnvironmentInfo } from '../../../api';
-import { isUvManagedPythonInstall, refreshPythons, resolveSystemPythonEnvironmentPath } from '../../../managers/builtin/utils';
+import {
+    getDefaultGlobalPython,
+    isUvManagedPythonInstall,
+    refreshPythons,
+    resolveSystemPythonEnvironmentPath,
+} from '../../../managers/builtin/utils';
 import * as uvEnvironments from '../../../managers/builtin/uvEnvironments';
 import { findVirtualEnvironments, resolveVenvPythonEnvironmentPath } from '../../../managers/builtin/venvUtils';
 import {
@@ -151,4 +156,49 @@ suite('uv-managed Python installations', () => {
         assert.strictEqual(install?.shortDisplayName, '3.13.15 (uv)');
         assert.strictEqual(venv?.shortDisplayName, '3.13.15');
     });
+
+    suite('default global Python', () => {
+        let pythonOrg: NativeEnvInfo;
+
+        setup(async () => {
+            // An older installation that is not managed by uv (for example from python.org).
+            const prefix = path.join(tempRoot, 'Python312');
+            await fs.outputFile(executableIn(prefix), '');
+            pythonOrg = {
+                kind: NativePythonEnvironmentKind.globalPaths,
+                executable: executableIn(prefix),
+                prefix,
+                version: '3.12.10',
+            };
+        });
+
+        test('prefers an installation not managed by uv over a newer uv-managed one', async () => {
+            const envs = await refreshPythons(false, finderReturning([uvInstall, pythonOrg]), api, log, systemManager);
+
+            assert.strictEqual(
+                getDefaultGlobalPython(envs)?.environmentPath.fsPath,
+                Uri.file(pythonOrg.executable!).fsPath,
+            );
+        });
+
+        test('prefers an installation not managed by uv over a uv-managed one resolved by path', async () => {
+            const finder = finderReturning([uvInstall, pythonOrg]);
+            const envs = await refreshPythons(false, finderReturning([pythonOrg]), api, log, systemManager);
+            const resolved = await resolveSystemPythonEnvironmentPath(uvInstall.executable!, finder, api, systemManager);
+
+            assert.strictEqual(
+                getDefaultGlobalPython([resolved!, ...envs])?.environmentPath.fsPath,
+                Uri.file(pythonOrg.executable!).fsPath,
+            );
+        });
+
+        test('uses a uv-managed installation when it is the only Python', async () => {
+            const envs = await refreshPythons(false, finderReturning([uvInstall]), api, log, systemManager);
+
+            assert.strictEqual(
+                getDefaultGlobalPython(envs)?.environmentPath.fsPath,
+                Uri.file(uvInstall.executable!).fsPath,
+            );
+        });
+    });
 });