Allow execute on enter and Intellisense for native REPL with notebook UI

package.json

@@ -311,6 +311,11 @@
                 "command": "python.execInREPL",
                 "title": "%python.command.python.execInREPL.title%"
             },
+            {
+                "category": "Python",
+                "command": "python.execInREPLEnter",
+                "title": "%python.command.python.execInREPLEnter.title%"
+            },
             {
                 "category": "Python",
                 "command": "python.launchTensorBoard",
@@ -1110,6 +1115,11 @@
                 "key": "shift+enter",
                 "when": "editorTextFocus && editorLangId == python && !findInputFocussed && !replaceInputFocussed && !jupyter.ownsSelection && !notebookEditorFocused && activeEditor != 'workbench.editor.interactive'"
             },
+            {
+                "command": "python.execInREPLEnter",
+                "key": "enter",
+                "when": "activeEditor == 'workbench.editor.interactive'"
+            },
             {
                 "command": "python.refreshTensorBoard",
                 "key": "ctrl+r",
@@ -1269,6 +1279,12 @@
                     "title": "%python.command.python.execInREPL.title%",
                     "when": "false"
                 },
+                {
+                    "category": "Python",
+                    "command": "python.execInREPLEnter",
+                    "title": "%python.command.python.execInREPLEnter.title%",
+                    "when": "false"
+                },
                 {
                     "category": "Python",
                     "command": "python.launchTensorBoard",

package.nls.json

@@ -15,6 +15,7 @@
     "python.command.testing.rerunFailedTests.title": "Rerun Failed Tests",
     "python.command.python.execSelectionInTerminal.title": "Run Selection/Line in Python Terminal",
     "python.command.python.execInREPL.title": "Run Selection/Line in Python REPL",
+    "python.command.python.execInREPLEnter": "Execute on REPL Enter",
     "python.command.python.execSelectionInDjangoShell.title": "Run Selection/Line in Django Shell",
     "python.command.python.reportIssue.title": "Report Issue...",
     "python.command.python.enableSourceMapSupport.title": "Enable Source Map Support For Extension Debugging",

python_files/ctrlc.py

@@ -0,0 +1,12 @@
+# This file sends keyboard interrupt to Windows Python REPL instance
+import ctypes
+import sys
+
+kernel = ctypes.windll.kernel32
+
+pid = int(sys.argv[1])
+kernel.FreeConsole()
+kernel.AttachConsole(pid)
+kernel.SetConsoleCtrlHandler(None, 1)
+kernel.GenerateConsoleCtrlEvent(0, 0)
+sys.exit(0)

python_files/python_server.py

@@ -1,11 +1,14 @@
 from typing import Dict, List, Optional, Union
+# import debugpy
 
+# debugpy.connect(5678)
 import sys
 import json
 import contextlib
 import io
 import traceback
 import uuid
+import ast
 
 STDIN = sys.stdin
 STDOUT = sys.stdout
@@ -88,6 +91,17 @@ def exec_function(user_input):
     return eval
 
 
+def check_valid_command(request):
+    try:
+        user_input = request["params"]
+        ast.parse(user_input[0])
+        send_response("True", request["id"])
+        # return True
+    except SyntaxError:
+        send_response("False", request["id"])
+        # return False
+
+
 def execute(request, user_globals):
     str_output = CustomIO("<stdout>", encoding="utf-8")
     str_error = CustomIO("<stderr>", encoding="utf-8")
@@ -160,6 +174,8 @@ def get_headers():
                 request_json = json.loads(request_text)
                 if request_json["method"] == "execute":
                     execute(request_json, USER_GLOBALS)
+                if request_json["method"] == "check_valid_command":
+                    check_valid_command(request_json)
                 elif request_json["method"] == "exit":
                     sys.exit(0)
 

src/client/common/application/commands.ts

@@ -39,6 +39,7 @@ interface ICommandNameWithoutArgumentTypeMapping {
     [Commands.Exec_Selection_In_Terminal]: [];
     [Commands.Exec_Selection_In_Django_Shell]: [];
     [Commands.Exec_In_REPL]: [];
+    [Commands.Exec_In_REPL_Enter]: [];
     [Commands.Create_Terminal]: [];
     [Commands.PickLocalProcess]: [];
     [Commands.ClearStorage]: [];

src/client/common/constants.ts

@@ -48,6 +48,7 @@ export namespace Commands {
     export const Exec_In_Separate_Terminal = 'python.execInDedicatedTerminal';
     export const Exec_In_REPL = 'python.execInREPL';
     export const Exec_Selection_In_Django_Shell = 'python.execSelectionInDjangoShell';
+    export const Exec_In_REPL_Enter = 'python.execInREPLEnter';
     export const Exec_Selection_In_Terminal = 'python.execSelectionInTerminal';
     export const GetSelectedInterpreterPath = 'python.interpreterPath';
     export const InstallJupyter = 'python.installJupyter';

src/client/extensionActivation.ts

@@ -53,7 +53,7 @@ import { initializePersistentStateForTriggers } from './common/persistentState';
 import { logAndNotifyOnLegacySettings } from './logging/settingLogs';
 import { DebuggerTypeName } from './debugger/constants';
 import { StopWatch } from './common/utils/stopWatch';
-import { registerReplCommands } from './repl/replCommands';
+import { registerReplCommands, registerReplExecuteOnEnter } from './repl/replCommands';
 import { EnableRunREPL } from './common/experiments/groups';
 
 export async function activateComponents(
@@ -117,6 +117,7 @@ export function activateFeatures(ext: ExtensionState, _components: Components):
         if (replExperimentValue) {
             registerReplCommands(ext.disposables, interpreterService);
             commands.executeCommand('setContext', 'pythonRunREPL', true);
+            registerReplExecuteOnEnter(ext.disposables, interpreterService);
         }
     }
 }

src/client/repl/pythonServer.ts

@@ -1,3 +1,4 @@
+// eslint-disable-next-line max-classes-per-file
 import * as path from 'path';
 import * as ch from 'child_process';
 import * as rpc from 'vscode-jsonrpc/node';
@@ -6,15 +7,23 @@ import { EXTENSION_ROOT_DIR } from '../constants';
 import { traceError, traceLog } from '../logging';
 
 const SERVER_PATH = path.join(EXTENSION_ROOT_DIR, 'python_files', 'python_server.py');
-
+// export let serverInstance: PythonServer | undefined;
+export class pythonServerInstance {
+    public static serverInstance: PythonServer | undefined;
+}
 export interface PythonServer extends Disposable {
     execute(code: string): Promise<string>;
     interrupt(): void;
     input(): void;
+    checkValidCommand(code: string): Promise<string>;
 }
 
 class PythonServerImpl implements Disposable {
-    constructor(private connection: rpc.MessageConnection, private pythonServer: ch.ChildProcess) {
+    constructor(
+        private connection: rpc.MessageConnection,
+        private pythonServer: ch.ChildProcess,
+        private interpreter: string,
+    ) {
         this.initialize();
         this.input();
     }
@@ -49,18 +58,41 @@ class PythonServerImpl implements Disposable {
     }
 
     public interrupt(): void {
+        // Passing SIGINT to interrupt only would work for Mac and Linux
         if (this.pythonServer.kill('SIGINT')) {
-            traceLog('Python server interrupted');
+            traceLog('Python REPL server interrupted');
+        } else {
+            // Handle interrupt for windows
+            // Run python_files/ctrlc.py with 12345 as argument
+            const ctrlc = ch.spawn(this.interpreter, [
+                path.join(EXTENSION_ROOT_DIR, 'python_files', 'ctrlc.py'),
+                '12345',
+            ]);
+            ctrlc.on('exit', (code) => {
+                if (code === 0) {
+                    traceLog('Windows Python REPL server interrupted successfully with exit code 0');
+                } else {
+                    traceLog('Windows Python REPL interrupt may have failed');
+                }
+            });
         }
     }
 
+    public async checkValidCommand(code: string): Promise<string> {
+        return this.connection.sendRequest('check_valid_command', code);
+    }
+
     public dispose(): void {
         this.connection.sendNotification('exit');
         this.connection.dispose();
     }
 }
 
 export function createPythonServer(interpreter: string[]): PythonServer {
+    if (pythonServerInstance.serverInstance) {
+        return pythonServerInstance.serverInstance;
+    }
+
     const pythonServer = ch.spawn(interpreter[0], [...interpreter.slice(1), SERVER_PATH]);
 
     pythonServer.stderr.on('data', (data) => {
@@ -76,6 +108,7 @@ export function createPythonServer(interpreter: string[]): PythonServer {
         new rpc.StreamMessageReader(pythonServer.stdout),
         new rpc.StreamMessageWriter(pythonServer.stdin),
     );
-
-    return new PythonServerImpl(connection, pythonServer);
+    const ourPythonServerImpl = new PythonServerImpl(connection, pythonServer, interpreter[0]);
+    pythonServerInstance.serverInstance = ourPythonServerImpl;
+    return ourPythonServerImpl;
 }

src/client/repl/replCommands.ts

@@ -12,12 +12,14 @@ import {
     WorkspaceEdit,
     NotebookEditor,
     TextEditor,
+    Selection,
 } from 'vscode';
 import { Disposable } from 'vscode-jsonrpc';
 import { Commands, PVSC_EXTENSION_ID } from '../common/constants';
 import { noop } from '../common/utils/misc';
 import { IInterpreterService } from '../interpreter/contracts';
 import { getMultiLineSelectionText, getSingleLineSelectionText } from '../terminals/codeExecution/helper';
+import { createPythonServer } from './pythonServer';
 import { createReplController } from './replController';
 
 let notebookController: NotebookController | undefined;
@@ -102,3 +104,63 @@ export async function registerReplCommands(
         }),
     );
 }
+
+// TODO: Register Python execute command for keybinding 'Enter'
+// TODO: Conditionally call interactive.execute OR insert \n in text input box.
+export async function registerReplExecuteOnEnter(
+    disposables: Disposable[],
+    interpreterService: IInterpreterService,
+): Promise<void> {
+    disposables.push(
+        commands.registerCommand(Commands.Exec_In_REPL_Enter, async (uri: Uri) => {
+            const interpreter = await interpreterService.getActiveInterpreter(uri);
+            if (!interpreter) {
+                commands.executeCommand(Commands.TriggerEnvironmentSelection, uri).then(noop, noop);
+                return;
+            }
+
+            // Create Separate Python server to check valid command
+            const pythonServer = createPythonServer([interpreter!.path! as string]);
+
+            const activeEditor = window.activeTextEditor;
+            let userTextInput;
+            let completeCode = false;
+
+            if (activeEditor) {
+                const { document } = activeEditor;
+                userTextInput = document.getText();
+            }
+
+            // Check if userTextInput is a complete Python command
+            if (userTextInput) {
+                const stringBoolean = await pythonServer.checkValidCommand(userTextInput);
+                if (stringBoolean === 'True') {
+                    completeCode = true;
+                }
+            }
+
+            if (completeCode) {
+                await commands.executeCommand('interactive.execute');
+            } else {
+                // Insert new line on behalf of user. "Regular" monaco editor behavior
+                const editor = window.activeTextEditor;
+
+                if (editor) {
+                    const position = editor.selection.active;
+                    // move cursor to end of line and also add newline character
+                    const newPosition = position.with(position.line, editor.document.lineAt(position.line).text.length);
+                    editor.selection = new Selection(newPosition, newPosition);
+                    // add newline character
+                    editor.edit((editBuilder) => {
+                        editBuilder.insert(newPosition, '\n');
+                    });
+                }
+
+                // Handle case when user enters on blank line, just trigger interactive.execute
+                if (editor && editor.document.lineAt(editor.selection.active.line).text === '') {
+                    await commands.executeCommand('interactive.execute');
+                }
+            }
+        }),
+    );
+}