Environments: synchronize the public active environment API

src/client/envExt/api.internal.ts

@@ -78,6 +78,10 @@ export function onDidChangeEnvironmentEnvExt(
 }
 
 let _extApi: PythonEnvironmentApi | undefined;
+export function getCachedEnvExtApi(): PythonEnvironmentApi | undefined {
+    return _extApi;
+}
+
 export async function getEnvExtApi(): Promise<PythonEnvironmentApi> {
     if (_extApi) {
         return _extApi;
@@ -128,6 +132,20 @@ export async function resolveEnvironment(pythonPath: string): Promise<PythonEnvi
     return envExtApi.resolveEnvironment(Uri.file(pythonPath));
 }
 
+export async function setActiveEnvironment(
+    pythonPath: string,
+    scope: GetEnvironmentScope,
+): Promise<PythonEnvironment | undefined> {
+    const envExtApi = await getEnvExtApi();
+    const environment = await envExtApi.resolveEnvironment(Uri.file(pythonPath));
+    if (!environment) {
+        traceError(`EnvExt: Failed to resolve environment for ${pythonPath}`);
+        return undefined;
+    }
+    await envExtApi.setEnvironment(scope, environment);
+    return environment;
+}
+
 export async function refreshEnvironments(scope: RefreshEnvironmentsScope): Promise<void> {
     const envExtApi = await getEnvExtApi();
     return envExtApi.refreshEnvironments(scope);

src/client/envExt/api.legacy.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 import { Terminal, Uri } from 'vscode';
-import { getEnvExtApi, getEnvironment } from './api.internal';
+import { getEnvExtApi, getEnvironment, setActiveEnvironment } from './api.internal';
 import { EnvironmentType, PythonEnvironment as PythonEnvironmentLegacy } from '../pythonEnvironments/info';
 import { PythonEnvironment, PythonTerminalCreateOptions } from './types';
 import { Architecture } from '../common/utils/platform';
@@ -150,13 +150,7 @@ export async function getActiveInterpreterLegacy(
 }
 
 export async function setInterpreterLegacy(pythonPath: string, uri: Uri | undefined): Promise<void> {
-    const api = await getEnvExtApi();
-    const pythonEnv = await api.resolveEnvironment(Uri.file(pythonPath));
-    if (!pythonEnv) {
-        traceError(`EnvExt: Failed to resolve environment for ${pythonPath}`);
-        return;
-    }
-    await api.setEnvironment(uri, pythonEnv);
+    await setActiveEnvironment(pythonPath, uri);
 }
 
 export async function resetInterpreterLegacy(uri: Uri | undefined): Promise<void> {

src/client/envExt/types.ts

@@ -924,6 +924,14 @@ export interface PythonProjectEnvironmentApi {
      */
     getEnvironment(scope: GetEnvironmentScope): Promise<PythonEnvironment | undefined>;
 
+    /**
+     * Synchronously retrieves the last-known Python environment within the specified scope.
+     * This does not trigger environment discovery or refresh.
+     * @param scope - The scope within which to retrieve the environment.
+     * @returns The last-known Python environment, or undefined if none has been resolved.
+     */
+    getEnvironmentSync(scope: GetEnvironmentScope): PythonEnvironment | undefined;
+
     /**
      * Event that is fired when the selected Python environment changes for Project, Folder or File.
      * @see {@link DidChangeEnvironmentEventArgs}

src/client/environmentApi.ts

@@ -35,6 +35,13 @@ import { buildEnvironmentCreationApi } from './pythonEnvironments/creation/creat
 import { EnvironmentKnownCache } from './environmentKnownCache';
 import type { JupyterPythonEnvironmentApi } from './jupyter/jupyterIntegration';
 import { noop } from './common/utils/misc';
+import {
+    getCachedEnvExtApi,
+    onDidChangeEnvironmentEnvExt,
+    setActiveEnvironment,
+    useEnvExtension,
+} from './envExt/api.internal';
+import type { PythonEnvironment as EnvExtPythonEnvironment } from './envExt/types';
 
 type ActiveEnvironmentChangeEvent = {
     resource: WorkspaceFolder | undefined;
@@ -131,6 +138,34 @@ export function buildEnvironmentApi(
     const extensions = serviceContainer.get<IExtensions>(IExtensions);
     const envVarsProvider = serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider);
     let knownCache: EnvironmentKnownCache;
+    const activeEnvExtPaths = new Map<string, string>();
+
+    function getActiveEnvironmentKey(resource?: Resource): string {
+        const uri = resource && 'uri' in resource ? resource.uri : resource;
+        return getWorkspaceFolder(uri)?.uri.fsPath ?? uri?.fsPath ?? '';
+    }
+
+    function cacheActiveEnvExtPath(
+        resource: Resource | undefined,
+        environment: EnvExtPythonEnvironment | undefined,
+    ): void {
+        const key = getActiveEnvironmentKey(resource);
+        if (!environment) {
+            activeEnvExtPaths.delete(key);
+            return;
+        }
+        activeEnvExtPaths.set(key, environment.execInfo.run.executable);
+    }
+
+    if (useEnvExtension()) {
+        const envExtApi = getCachedEnvExtApi();
+        if (envExtApi) {
+            cacheActiveEnvExtPath(undefined, envExtApi.getEnvironmentSync(undefined));
+            getWorkspaceFolders()?.forEach((folder) =>
+                cacheActiveEnvExtPath(folder.uri, envExtApi.getEnvironmentSync(folder.uri)),
+            );
+        }
+    }
 
     function initKnownCache() {
         const knownEnvs = discoveryApi
@@ -169,6 +204,13 @@ export function buildEnvironmentApi(
                 path: jupyterEnv.path,
             };
         }
+        const envExtPath = activeEnvExtPaths.get(getActiveEnvironmentKey(resource));
+        if (useEnvExtension() && envExtPath) {
+            return {
+                id: getEnvID(envExtPath),
+                path: envExtPath,
+            };
+        }
         const path = configService.getSettings(resource).pythonPath;
         const id = path === 'python' ? 'DEFAULT_PYTHON' : getEnvID(path);
         return {
@@ -242,6 +284,15 @@ export function buildEnvironmentApi(
                 env: envVarsProvider.getEnvironmentVariablesSync(e),
             });
         }),
+        onDidChangeEnvironmentEnvExt((e) => {
+            cacheActiveEnvExtPath(e.uri, e.new);
+            if (e.new) {
+                reportActiveInterpreterChanged({
+                    resource: getWorkspaceFolder(e.uri),
+                    path: e.new.execInfo.run.executable,
+                });
+            }
+        }),
         onEnvironmentsChanged,
         onEnvironmentVariablesChanged,
         jupyterPythonEnvsApi.onDidChangePythonEnvironment
@@ -273,10 +324,18 @@ export function buildEnvironmentApi(
             sendApiTelemetry('getActiveEnvironmentPath');
             return getActiveEnvironmentPath(resource);
         },
-        updateActiveEnvironmentPath(env: Environment | EnvironmentPath | string, resource?: Resource): Promise<void> {
+        async updateActiveEnvironmentPath(
+            env: Environment | EnvironmentPath | string,
+            resource?: Resource,
+        ): Promise<void> {
             sendApiTelemetry('updateActiveEnvironmentPath');
             const path = typeof env !== 'string' ? env.path : env;
             resource = resource && 'uri' in resource ? resource.uri : resource;
+            if (useEnvExtension()) {
+                const environment = await setActiveEnvironment(path, resource);
+                cacheActiveEnvExtPath(resource, environment);
+                return;
+            }
             return interpreterPathService.update(resource, ConfigurationTarget.WorkspaceFolder, path);
         },
         get onDidChangeActiveEnvironmentPath() {

src/test/environmentApi.unit.test.ts

@@ -39,6 +39,8 @@ import {
     PythonExtension,
 } from '../client/api/types';
 import { JupyterPythonEnvironmentApi } from '../client/jupyter/jupyterIntegration';
+import * as envExtApi from '../client/envExt/api.internal';
+import { DidChangeEnvironmentEventArgs, PythonEnvironment } from '../client/envExt/types';
 
 suite('Python Environment API', () => {
     const workspacePath = 'path/to/workspace';
@@ -57,6 +59,9 @@ suite('Python Environment API', () => {
     let onDidChangeRefreshState: EventEmitter<ProgressNotificationEvent>;
     let onDidChangeEnvironments: EventEmitter<PythonEnvCollectionChangedEvent>;
     let onDidChangeEnvironmentVariables: EventEmitter<Uri | undefined>;
+    let onDidChangeEnvExtEnvironment: EventEmitter<DidChangeEnvironmentEventArgs>;
+    let useEnvExtension: boolean;
+    let jupyterApi: JupyterPythonEnvironmentApi;
 
     let environmentApi: PythonExtension['environments'];
 
@@ -81,6 +86,14 @@ suite('Python Environment API', () => {
         onDidChangeRefreshState = new EventEmitter();
         onDidChangeEnvironments = new EventEmitter();
         onDidChangeEnvironmentVariables = new EventEmitter();
+        onDidChangeEnvExtEnvironment = new EventEmitter();
+        useEnvExtension = false;
+        sinon.stub(envExtApi, 'useEnvExtension').callsFake(() => useEnvExtension);
+        sinon
+            .stub(envExtApi, 'onDidChangeEnvironmentEnvExt')
+            .callsFake((listener, thisArgs, disposables) =>
+                onDidChangeEnvExtEnvironment.event(listener, thisArgs, disposables),
+            );
         serviceContainer.setup((s) => s.get(IExtensions)).returns(() => extensions.object);
         serviceContainer.setup((s) => s.get(IInterpreterPathService)).returns(() => interpreterPathService.object);
         serviceContainer.setup((s) => s.get(IConfigurationService)).returns(() => configService.object);
@@ -95,7 +108,7 @@ suite('Python Environment API', () => {
         discoverAPI.setup((d) => d.onChanged).returns(() => onDidChangeEnvironments.event);
         discoverAPI.setup((d) => d.getEnvs()).returns(() => []);
         const onDidChangePythonEnvironment = new EventEmitter<Uri>();
-        const jupyterApi: JupyterPythonEnvironmentApi = {
+        jupyterApi = {
             onDidChangePythonEnvironment: onDidChangePythonEnvironment.event,
             getPythonEnvironment: (_uri: Uri) => undefined,
         };
@@ -194,6 +207,65 @@ suite('Python Environment API', () => {
         });
     });
 
+    test('getActiveEnvironmentPath: uses environment extension selection', () => {
+        const configuredPath = Uri.joinPath(workspaceFolder.uri, 'env-a', 'python').fsPath;
+        const selectedPath = Uri.joinPath(workspaceFolder.uri, 'env-b', 'python').fsPath;
+        configService
+            .setup((c) => c.getSettings(workspaceFolder.uri))
+            .returns(() => (({ pythonPath: configuredPath } as unknown) as IPythonSettings));
+        useEnvExtension = true;
+
+        onDidChangeEnvExtEnvironment.fire({
+            uri: workspaceFolder.uri,
+            old: undefined,
+            new: {
+                envId: { id: 'env-b', managerId: 'ms-python.python:venv' },
+                name: 'env-b',
+                displayName: 'env-b',
+                displayPath: 'env-b',
+                version: '3.12.0',
+                environmentPath: Uri.joinPath(workspaceFolder.uri, 'env-b'),
+                execInfo: { run: { executable: selectedPath } },
+                sysPrefix: Uri.joinPath(workspaceFolder.uri, 'env-b').fsPath,
+            } as PythonEnvironment,
+        });
+
+        assert.deepEqual(environmentApi.getActiveEnvironmentPath(workspaceFolder.uri), {
+            id: normCasePath(selectedPath),
+            path: selectedPath,
+        });
+    });
+
+    test('getActiveEnvironmentPath: uses selection present before API construction', () => {
+        const configuredPath = Uri.joinPath(workspaceFolder.uri, 'env-a', 'python').fsPath;
+        const selectedPath = Uri.joinPath(workspaceFolder.uri, 'env-b', 'python').fsPath;
+        const selectedEnvironment = {
+            envId: { id: 'env-b', managerId: 'ms-python.python:venv' },
+            name: 'env-b',
+            displayName: 'env-b',
+            displayPath: 'env-b',
+            version: '3.12.0',
+            environmentPath: Uri.joinPath(workspaceFolder.uri, 'env-b'),
+            execInfo: { run: { executable: selectedPath } },
+            sysPrefix: Uri.joinPath(workspaceFolder.uri, 'env-b').fsPath,
+        } as PythonEnvironment;
+        configService
+            .setup((c) => c.getSettings(workspaceFolder.uri))
+            .returns(() => (({ pythonPath: configuredPath } as unknown) as IPythonSettings));
+        sinon.stub(envExtApi, 'getCachedEnvExtApi').returns({
+            getEnvironmentSync: (scope) =>
+                scope?.fsPath === workspaceFolder.uri.fsPath ? selectedEnvironment : undefined,
+        } as ReturnType<typeof envExtApi.getCachedEnvExtApi>);
+        useEnvExtension = true;
+
+        environmentApi = buildEnvironmentApi(discoverAPI.object, serviceContainer.object, jupyterApi);
+
+        assert.deepEqual(environmentApi.getActiveEnvironmentPath(workspaceFolder.uri), {
+            id: normCasePath(selectedPath),
+            path: selectedPath,
+        });
+    });
+
     test('resolveEnvironment: invalid environment (when passed as string)', async () => {
         const pythonPath = 'this/is/a/test/path';
         discoverAPI.setup((p) => p.resolveEnv(pythonPath)).returns(() => Promise.resolve(undefined));
@@ -493,6 +565,37 @@ suite('Python Environment API', () => {
         interpreterPathService.verifyAll();
     });
 
+    test('updateActiveEnvironmentPath: delegates to environment extension', async () => {
+        const pythonPath = Uri.joinPath(workspaceFolder.uri, 'env-b', 'python').fsPath;
+        const selectedEnvironment = {
+            envId: { id: 'env-b', managerId: 'ms-python.python:venv' },
+            name: 'env-b',
+            displayName: 'env-b',
+            displayPath: 'env-b',
+            version: '3.12.0',
+            environmentPath: Uri.joinPath(workspaceFolder.uri, 'env-b'),
+            execInfo: { run: { executable: pythonPath } },
+            sysPrefix: Uri.joinPath(workspaceFolder.uri, 'env-b').fsPath,
+        } as PythonEnvironment;
+        const setActiveEnvironment = sinon.stub(envExtApi, 'setActiveEnvironment').resolves(selectedEnvironment);
+        configService
+            .setup((c) => c.getSettings(workspaceFolder.uri))
+            .returns(() => (({ pythonPath: 'stale' } as unknown) as IPythonSettings));
+        useEnvExtension = true;
+
+        await environmentApi.updateActiveEnvironmentPath(pythonPath, workspaceFolder);
+
+        sinon.assert.calledOnceWithExactly(setActiveEnvironment, pythonPath, workspaceFolder.uri);
+        assert.deepEqual(environmentApi.getActiveEnvironmentPath(workspaceFolder.uri), {
+            id: normCasePath(pythonPath),
+            path: pythonPath,
+        });
+        interpreterPathService.verify(
+            (i) => i.update(typemoq.It.isAny(), typemoq.It.isAny(), typemoq.It.isAny()),
+            typemoq.Times.never(),
+        );
+    });
+
     test('refreshInterpreters: default', async () => {
         discoverAPI
             .setup((d) => d.triggerRefresh(undefined, typemoq.It.isValue({ ifNotTriggerredAlready: true })))