Preserve per-script routing after PR6 merge

Keep exact script-project settings authoritative while routing active inline selections ahead of containing-project defaults, and retain strict PEP 440 validation for persisted associations.

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

Copilot-Session: 1a9f6ba1-9bd3-4664-bc25-a0d34d7a2e91

Author: StellaHuang95

src/features/envManagers.ts

@@ -38,6 +38,7 @@ import {
     EditAllManagerSettings,
     getDefaultEnvManagerSetting,
     getDefaultPkgManagerSetting,
+    getProjectEnvironmentManagerSetting,
     setAllManagerSettings,
 } from './settings/settingHelpers';
 
@@ -195,10 +196,11 @@ export class PythonEnvironmentManagers implements EnvironmentManagers {
      * Returns the environment manager for the given context.
      *
      * Priority:
-     * 1. Use the default from settings (user-configured takes precedence)
-     * 2. If no user-configured setting, fall back to cached environment's manager
-     * 3. If context is a string (manager ID), return that manager directly
-     * 4. If context is a PythonEnvironment, return its manager
+     * 1. Use an exact per-script project setting.
+     * 2. Use a cached per-script inline selection.
+     * 3. Use the containing project or default setting.
+     * 4. Fall back to the cached project/global environment's manager.
+     * 5. If context is a string or PythonEnvironment, return its manager directly.
      */
     public getEnvironmentManager(context: EnvironmentManagerScope): InternalEnvironmentManager | undefined {
         if (this._environmentManagers.size === 0) {
@@ -207,7 +209,31 @@ export class PythonEnvironmentManagers implements EnvironmentManagers {
         }
 
         if (context === undefined || context instanceof Uri) {
-            // First check settings - user-configured settings always take priority
+            const project = context ? this.pm.get(context) : undefined;
+            if (
+                context instanceof Uri &&
+                project &&
+                normalizePath(project.uri.fsPath) === normalizePath(context.fsPath)
+            ) {
+                const exactManagerId = getProjectEnvironmentManagerSetting(this.pm, context);
+                const exactManager = exactManagerId
+                    ? this._environmentManagers.get(exactManagerId)
+                    : undefined;
+                if (exactManager) {
+                    return exactManager;
+                }
+            }
+
+            if (context instanceof Uri) {
+                const inlineEnv = this._activeSelection.get(this.getInlineScriptSelectionKey(context));
+                if (inlineEnv?.envId.managerId === INLINE_SCRIPT_MANAGER_ID) {
+                    const inlineManager = this._environmentManagers.get(INLINE_SCRIPT_MANAGER_ID);
+                    if (inlineManager) {
+                        return inlineManager;
+                    }
+                }
+            }
+
             const defaultEnvManagerId = getDefaultEnvManagerSetting(this.pm, context);
             if (defaultEnvManagerId !== undefined) {
                 const settingsManager = this._environmentManagers.get(defaultEnvManagerId);
@@ -216,13 +242,7 @@ export class PythonEnvironmentManagers implements EnvironmentManagers {
                 }
             }
 
-            // Fall back to cached environment's manager if no user-configured settings
-            const project = context ? this.pm.get(context) : undefined;
-            const cachedEnv =
-                (context instanceof Uri
-                    ? this._activeSelection.get(this.getInlineScriptSelectionKey(context))
-                    : undefined) ??
-                this._activeSelection.get(project ? project.uri.toString() : 'global');
+            const cachedEnv = this._activeSelection.get(project ? project.uri.toString() : 'global');
             if (cachedEnv) {
                 const cachedManager = this._environmentManagers.get(cachedEnv.envId.managerId);
                 if (cachedManager) {
@@ -343,6 +363,9 @@ export class PythonEnvironmentManagers implements EnvironmentManagers {
         const project = scope ? this.pm.get(scope) : undefined;
         const key = this.getActiveSelectionKey(scope, manager, project);
         await manager.set(scope, environment);
+        if (scope instanceof Uri) {
+            this.clearInlineActiveSelection(scope, manager);
+        }
         this.bumpSelectionRevision(key);
 
         // Only persist to settings when explicitly requested
@@ -422,6 +445,7 @@ export class PythonEnvironmentManagers implements EnvironmentManagers {
             if (Array.isArray(scope) && scope.every((s) => s instanceof Uri)) {
                 await manager.set(scope, environment);
                 scope.forEach((uri) => {
+                    this.clearInlineActiveSelection(uri, manager);
                     const project = this.pm.get(uri);
                     this.bumpSelectionRevision(this.getActiveSelectionKey(uri, manager, project));
                 });
@@ -670,6 +694,16 @@ export class PythonEnvironmentManagers implements EnvironmentManagers {
         return `inline-script:${normalizePath(scope.fsPath)}`;
     }
 
+    private clearInlineActiveSelection(scope: Uri, manager: InternalEnvironmentManager): void {
+        if (manager.id === INLINE_SCRIPT_MANAGER_ID) {
+            return;
+        }
+        const key = this.getInlineScriptSelectionKey(scope);
+        if (this._activeSelection.delete(key)) {
+            this.bumpSelectionRevision(key);
+        }
+    }
+
     private canPersistManagerSettingForScope(
         scope: Uri,
         manager: InternalEnvironmentManager,

src/features/settings/settingHelpers.ts

@@ -28,6 +28,15 @@ function getSettings(
     return undefined;
 }
 
+export function getProjectEnvironmentManagerSetting(
+    wm: PythonProjectManager,
+    scope: Uri,
+): string | undefined {
+    const config = workspaceApis.getConfiguration('python-envs', scope);
+    const setting = getSettings(wm, config, scope)?.envManager;
+    return setting ? setting : undefined;
+}
+
 let DEFAULT_ENV_MANAGER_BROKEN = false;
 let hasShownDefaultEnvManagerBrokenWarn = false;
 

src/test/features/envManagers.lastKnown.unit.test.ts

@@ -32,6 +32,8 @@ suite('PythonEnvironmentManagers getLastKnownEnvironment', () => {
     let envManagers: PythonEnvironmentManagers;
     let projectManager: typeMoq.IMock<PythonProjectManager>;
     let projectsByUri: Map<string, PythonProject>;
+    let defaultManagerId: string;
+    let exactManagerSettings: Map<string, string>;
 
     function makeEnv(id: string): PythonEnvironment {
         const envId: PythonEnvironmentId = { id, managerId: 'test-manager' };
@@ -61,11 +63,16 @@ suite('PythonEnvironmentManagers getLastKnownEnvironment', () => {
         projectManager = typeMoq.Mock.ofType<PythonProjectManager>();
         setupNonThenable(projectManager);
         projectsByUri = new Map();
+        exactManagerSettings = new Map();
         projectManager
             .setup((pm) => pm.get(typeMoq.It.isAny()))
             .returns((uri) => projectsByUri.get(uri.toString()));
 
         envManagers = new PythonEnvironmentManagers(projectManager.object);
+        sinon.stub(settingHelpers, 'getDefaultEnvManagerSetting').callsFake(() => defaultManagerId);
+        sinon
+            .stub(settingHelpers, 'getProjectEnvironmentManagerSetting')
+            .callsFake((_manager, uri) => exactManagerSettings.get(uri.toString()));
     });
 
     teardown(() => {
@@ -93,10 +100,10 @@ suite('PythonEnvironmentManagers getLastKnownEnvironment', () => {
             refresh: async () => undefined,
         } as unknown as EnvironmentManager;
 
+        const managerIndex = envManagers.managers.length;
         envManagers.registerEnvironmentManager(manager);
-        const id = envManagers.managers[0].id;
-        // Force the default environment manager (used for undefined/global scope) to resolve to ours.
-        sinon.stub(settingHelpers, 'getDefaultEnvManagerSetting').returns(id);
+        const id = envManagers.managers[managerIndex].id;
+        defaultManagerId = id;
         return id;
     }
 
@@ -250,6 +257,53 @@ suite('PythonEnvironmentManagers getLastKnownEnvironment', () => {
         assert.strictEqual(envManagers.getLastKnownEnvironment(secondUri), second);
     });
 
+    test('routes an active inline-script selection before the containing project default', async () => {
+        const script = Uri.file('/workspace/project/script.py');
+        projectsByUri.set(script.toString(), { name: 'project', uri: Uri.file('/workspace/project') });
+        const defaultId = registerManager(async () => makeEnv('default'), async () => undefined, 'venv');
+        let inlineEnvironment: PythonEnvironment;
+        const inlineId = registerManager(async () => inlineEnvironment, async () => undefined, 'inline-script');
+        inlineEnvironment = { ...makeEnv('inline'), envId: { id: 'inline', managerId: inlineId } };
+        defaultManagerId = defaultId;
+
+        await envManagers.setEnvironment(script, inlineEnvironment, false);
+
+        assert.strictEqual(envManagers.getEnvironmentManager(script)?.id, inlineId);
+        assert.strictEqual(await envManagers.getEnvironment(script), inlineEnvironment);
+    });
+
+    test('lets an exact script project setting override an active inline selection', async () => {
+        const script = Uri.file('/workspace/script.py');
+        projectsByUri.set(script.toString(), { name: 'script.py', uri: script });
+        const selectedId = registerManager(async () => makeEnv('selected'), async () => undefined, 'venv');
+        let inlineEnvironment: PythonEnvironment;
+        const inlineId = registerManager(async () => inlineEnvironment, async () => undefined, 'inline-script');
+        inlineEnvironment = { ...makeEnv('inline'), envId: { id: 'inline', managerId: inlineId } };
+        defaultManagerId = selectedId;
+
+        await envManagers.setEnvironment(script, inlineEnvironment, false);
+        exactManagerSettings.set(script.toString(), selectedId);
+
+        assert.strictEqual(envManagers.getEnvironmentManager(script)?.id, selectedId);
+    });
+
+    test('clears active inline routing after selecting a different manager', async () => {
+        const script = Uri.file('/workspace/project/script.py');
+        projectsByUri.set(script.toString(), { name: 'project', uri: Uri.file('/workspace/project') });
+        let selectedEnvironment: PythonEnvironment;
+        const selectedId = registerManager(async () => selectedEnvironment, async () => undefined, 'venv');
+        let inlineEnvironment: PythonEnvironment;
+        const inlineId = registerManager(async () => inlineEnvironment, async () => undefined, 'inline-script');
+        selectedEnvironment = { ...makeEnv('selected'), envId: { id: 'selected', managerId: selectedId } };
+        inlineEnvironment = { ...makeEnv('inline'), envId: { id: 'inline', managerId: inlineId } };
+        defaultManagerId = selectedId;
+
+        await envManagers.setEnvironment(script, inlineEnvironment, false);
+        await envManagers.setEnvironment(script, selectedEnvironment, false);
+
+        assert.strictEqual(envManagers.getEnvironmentManager(script)?.id, selectedId);
+    });
+
     test('does not persist an inline-script manager for the containing project', async () => {
         const script = Uri.file('/workspace/project/script.py');
         const containingProject = { name: 'project', uri: Uri.file('/workspace/project') };

src/test/managers/builtin/inlineScript/envManager.unit.test.ts

@@ -1631,6 +1631,18 @@ suite('InlineScriptEnvManager', () => {
             assert.strictEqual(await manager.get(uri), environment);
         });
 
+        test('uses full PEP 440 semantics when validating a retained association', async () => {
+            const uri = scriptUri();
+            const environment = {
+                ...(await createOwnedEnvironment()),
+                version: '3.15.0',
+            };
+            await manager.set(uri, environment);
+            readMetadataStub.resolves({ ...VALID_METADATA, requiresPython: '!=3.15.0rc2' });
+
+            assert.strictEqual(await manager.get(uri), environment);
+        });
+
         test('does not resolve or discard an association when metadata is absent or unreadable', async () => {
             const uri = scriptUri();
             const environment = await createOwnedEnvironment();