Merge branch 'main' into don/issue15987

Author: DonJayamanne

.github/release_plan.md

@@ -24,8 +24,10 @@ Feature freeze is Monday @ 17:00 America/Vancouver, XXX XX. At that point, commi
 </details>
 
 
-# Release candidate (Monday, XXX XX)
+# Release candidate (Thursday, XXX XX)
+NOTE: This Thursday occurs during TESTING week. Branching should be done during this week to freeze the release with only the correct changes. Any last minute fixes go in as candidates into the release branch and will require team approval.
 
+Other:
 NOTE: Third Party Notices are automatically added by our build pipelines using  https://tools.opensource.microsoft.com/notice.
 NOTE: the number of this release is in the issue title and can be substituted in wherever you see [YYYY.minor].
 

package-lock.json

@@ -2,7 +2,7 @@
     "name": "python",
     "displayName": "Python",
     "description": "Python language support with extension access points for IntelliSense (Pylance), Debugging (Python Debugger), linting, formatting, refactoring, unit tests, and more.",
-    "version": "2024.23.0-dev",
+    "version": "2025.1.0-dev",
     "featureFlags": {
         "usingNewInterpreterStorage": true
     },

package.json

@@ -25,6 +25,7 @@ import { useEnvExtension } from '../../envExt/api.internal';
 import { ensureTerminalLegacy } from '../../envExt/api.legacy';
 import { sleep } from '../utils/async';
 import { isWindows } from '../utils/platform';
+import { getPythonMinorVersion } from '../../repl/replUtils';
 
 @injectable()
 export class TerminalService implements ITerminalService, Disposable {
@@ -108,7 +109,15 @@ export class TerminalService implements ITerminalService, Disposable {
 
         const config = getConfiguration('python');
         const pythonrcSetting = config.get<boolean>('terminal.shellIntegration.enabled');
-        if ((isPythonShell && !pythonrcSetting) || (isPythonShell && isWindows())) {
+
+        const minorVersion = this.options?.resource
+            ? await getPythonMinorVersion(
+                  this.options.resource,
+                  this.serviceContainer.get<IInterpreterService>(IInterpreterService),
+              )
+            : undefined;
+
+        if ((isPythonShell && !pythonrcSetting) || (isPythonShell && isWindows()) || (minorVersion ?? 0) >= 13) {
             // If user has explicitly disabled SI for Python, use sendText for inside Terminal REPL.
             terminal.sendText(commandLine);
             return undefined;

src/client/common/terminal/service.ts

@@ -118,3 +118,17 @@ export function getTabNameForUri(uri: Uri): string | undefined {
 
     return undefined;
 }
+
+/**
+ * Function that will return the minor version of current active Python interpreter.
+ */
+export async function getPythonMinorVersion(
+    uri: Uri | undefined,
+    interpreterService: IInterpreterService,
+): Promise<number | undefined> {
+    if (uri) {
+        const pythonVersion = await getActiveInterpreter(uri, interpreterService);
+        return pythonVersion?.version?.minor;
+    }
+    return undefined;
+}

src/client/repl/replUtils.ts

@@ -11,21 +11,29 @@ import {
     TerminalShellExecution,
     TerminalShellExecutionEndEvent,
     TerminalShellIntegration,
+    Uri,
     Terminal as VSCodeTerminal,
     WorkspaceConfiguration,
 } from 'vscode';
 import { ITerminalManager, IWorkspaceService } from '../../../client/common/application/types';
 import { EXTENSION_ROOT_DIR } from '../../../client/common/constants';
 import { IPlatformService } from '../../../client/common/platform/types';
 import { TerminalService } from '../../../client/common/terminal/service';
-import { ITerminalActivator, ITerminalHelper, TerminalShellType } from '../../../client/common/terminal/types';
+import {
+    ITerminalActivator,
+    ITerminalHelper,
+    TerminalCreationOptions,
+    TerminalShellType,
+} from '../../../client/common/terminal/types';
 import { IDisposableRegistry } from '../../../client/common/types';
 import { IServiceContainer } from '../../../client/ioc/types';
 import { ITerminalAutoActivation } from '../../../client/terminals/types';
 import { createPythonInterpreter } from '../../utils/interpreters';
 import * as workspaceApis from '../../../client/common/vscodeApis/workspaceApis';
 import * as platform from '../../../client/common/utils/platform';
 import * as extapi from '../../../client/envExt/api.internal';
+import { IInterpreterService } from '../../../client/interpreter/contracts';
+import { PythonEnvironment } from '../../../client/pythonEnvironments/info';
 
 suite('Terminal Service', () => {
     let service: TerminalService;
@@ -46,6 +54,8 @@ suite('Terminal Service', () => {
     let editorConfig: TypeMoq.IMock<WorkspaceConfiguration>;
     let isWindowsStub: sinon.SinonStub;
     let useEnvExtensionStub: sinon.SinonStub;
+    let interpreterService: TypeMoq.IMock<IInterpreterService>;
+    let options: TypeMoq.IMock<TerminalCreationOptions>;
 
     setup(() => {
         useEnvExtensionStub = sinon.stub(extapi, 'useEnvExtension');
@@ -92,6 +102,13 @@ suite('Terminal Service', () => {
         disposables = [];
 
         mockServiceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
+        interpreterService = TypeMoq.Mock.ofType<IInterpreterService>();
+        interpreterService
+            .setup((i) => i.getActiveInterpreter(TypeMoq.It.isAny()))
+            .returns(() => Promise.resolve(({ path: 'ps' } as unknown) as PythonEnvironment));
+
+        options = TypeMoq.Mock.ofType<TerminalCreationOptions>();
+        options.setup((o) => o.resource).returns(() => Uri.parse('a'));
 
         mockServiceContainer.setup((c) => c.get(ITerminalManager)).returns(() => terminalManager.object);
         mockServiceContainer.setup((c) => c.get(ITerminalHelper)).returns(() => terminalHelper.object);
@@ -100,6 +117,7 @@ suite('Terminal Service', () => {
         mockServiceContainer.setup((c) => c.get(IWorkspaceService)).returns(() => workspaceService.object);
         mockServiceContainer.setup((c) => c.get(ITerminalActivator)).returns(() => terminalActivator.object);
         mockServiceContainer.setup((c) => c.get(ITerminalAutoActivation)).returns(() => terminalAutoActivator.object);
+        mockServiceContainer.setup((c) => c.get(IInterpreterService)).returns(() => interpreterService.object);
         getConfigurationStub = sinon.stub(workspaceApis, 'getConfiguration');
         isWindowsStub = sinon.stub(platform, 'isWindows');
         pythonConfig = TypeMoq.Mock.ofType<WorkspaceConfiguration>();
@@ -117,6 +135,7 @@ suite('Terminal Service', () => {
         }
         disposables.filter((item) => !!item).forEach((item) => item.dispose());
         sinon.restore();
+        interpreterService.reset();
     });
 
     test('Ensure terminal is disposed', async () => {
@@ -239,7 +258,7 @@ suite('Terminal Service', () => {
         terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.exactly(1));
     });
 
-    test('Ensure sendText is NOT called when Python shell integration and terminal shell integration are both enabled - Mac, Linux', async () => {
+    test('Ensure sendText is NOT called when Python shell integration and terminal shell integration are both enabled - Mac, Linux && Python < 3.13', async () => {
         isWindowsStub.returns(false);
         pythonConfig
             .setup((p) => p.get('terminal.shellIntegration.enabled'))
@@ -261,6 +280,36 @@ suite('Terminal Service', () => {
         terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.never());
     });
 
+    test('Ensure sendText is called when Python shell integration and terminal shell integration are both enabled - Mac, Linux && Python >= 3.13', async () => {
+        interpreterService.reset();
+
+        interpreterService
+            .setup((i) => i.getActiveInterpreter(TypeMoq.It.isAny()))
+            .returns(() =>
+                Promise.resolve({ path: 'yo', version: { major: 3, minor: 13, patch: 0 } } as PythonEnvironment),
+            );
+
+        isWindowsStub.returns(false);
+        pythonConfig
+            .setup((p) => p.get('terminal.shellIntegration.enabled'))
+            .returns(() => true)
+            .verifiable(TypeMoq.Times.once());
+
+        terminalHelper
+            .setup((helper) => helper.getEnvironmentActivationCommands(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+            .returns(() => Promise.resolve(undefined));
+
+        service = new TerminalService(mockServiceContainer.object, options.object);
+        const textToSend = 'Some Text';
+        terminalHelper.setup((h) => h.identifyTerminalShell(TypeMoq.It.isAny())).returns(() => TerminalShellType.bash);
+        terminalManager.setup((t) => t.createTerminal(TypeMoq.It.isAny())).returns(() => terminal.object);
+
+        await service.ensureTerminal();
+        await service.executeCommand(textToSend, true);
+
+        terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.once());
+    });
+
     test('Ensure sendText IS called even when Python shell integration and terminal shell integration are both enabled - Window', async () => {
         isWindowsStub.returns(true);
         pythonConfig

src/test/common/terminals/service.unit.test.ts

@@ -33,12 +33,12 @@ import { IServiceContainer } from '../../../client/ioc/types';
 import { EnvironmentType, PythonEnvironment } from '../../../client/pythonEnvironments/info';
 import { CodeExecutionHelper } from '../../../client/terminals/codeExecution/helper';
 import { ICodeExecutionHelper } from '../../../client/terminals/types';
-import { PYTHON_PATH } from '../../common';
+import { PYTHON_PATH, getPythonSemVer } from '../../common';
 import { ReplType } from '../../../client/repl/types';
 
 const TEST_FILES_PATH = path.join(EXTENSION_ROOT_DIR, 'src', 'test', 'python_files', 'terminalExec');
 
-suite('Terminal - Code Execution Helper', () => {
+suite('Terminal - Code Execution Helper', async () => {
     let activeResourceService: TypeMoq.IMock<IActiveResourceService>;
     let documentManager: TypeMoq.IMock<IDocumentManager>;
     let applicationShell: TypeMoq.IMock<IApplicationShell>;
@@ -234,25 +234,28 @@ suite('Terminal - Code Execution Helper', () => {
         expect(normalizedCode).to.be.equal(normalizedExpected);
     }
 
-    ['', '1', '2', '3', '4', '5', '6', '7', '8'].forEach((fileNameSuffix) => {
-        test(`Ensure code is normalized (Sample${fileNameSuffix})`, async () => {
-            configurationService
-                .setup((c) => c.getSettings(TypeMoq.It.isAny()))
-                .returns({
-                    REPL: {
-                        EnableREPLSmartSend: false,
-                        REPLSmartSend: false,
-                    },
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                } as any);
-            const code = await fs.readFile(path.join(TEST_FILES_PATH, `sample${fileNameSuffix}_raw.py`), 'utf8');
-            const expectedCode = await fs.readFile(
-                path.join(TEST_FILES_PATH, `sample${fileNameSuffix}_normalized_selection.py`),
-                'utf8',
-            );
-            await ensureCodeIsNormalized(code, expectedCode);
+    const pythonTestVersion = await getPythonSemVer();
+    if (pythonTestVersion && pythonTestVersion.minor < 13) {
+        ['', '1', '2', '3', '4', '5', '6', '7', '8'].forEach((fileNameSuffix) => {
+            test(`Ensure code is normalized (Sample${fileNameSuffix}) - Python < 3.13`, async () => {
+                configurationService
+                    .setup((c) => c.getSettings(TypeMoq.It.isAny()))
+                    .returns({
+                        REPL: {
+                            EnableREPLSmartSend: false,
+                            REPLSmartSend: false,
+                        },
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    } as any);
+                const code = await fs.readFile(path.join(TEST_FILES_PATH, `sample${fileNameSuffix}_raw.py`), 'utf8');
+                const expectedCode = await fs.readFile(
+                    path.join(TEST_FILES_PATH, `sample${fileNameSuffix}_normalized_selection.py`),
+                    'utf8',
+                );
+                await ensureCodeIsNormalized(code, expectedCode);
+            });
         });
-    });
+    }
 
     test("Display message if there's no active file", async () => {
         documentManager.setup((doc) => doc.activeTextEditor).returns(() => undefined);