Fix & test Windows bracketed pasting issue (#117)

* Improve testing docstrings & add convenience methods

* Add laggy patched preview test & test sample

* Remove code of fix #81

* Increase grid size a bit

* Also try to remove ESC+ENTER

* Install patch in site-packages

* Remove patch from test samples

* Improve error handling for when patch fails

* Only apply fix on Windows

* Fix wrong filename in test

* Make scene laggier

* Also escape \r in python string

* Decrease grid size and increase timeout for tests

* Simplify retrieval of python binary in environment

* Add docstring for windows patch

* Add docstring to function that executes patch and waits for success

* Use success string that is not in source code itself

* Use `python` instead of `python3`

* Use Node.js `exec` instead of spawning new VSCode terminal

See this comment:
#117 (comment)

* Remove prints in Python patch

* Test that windows paste patch is correctly applied

* Fix logger import path

* Run all tests 🙈 (remove `it.only()` call)

* Restore accidentally deleted lines

* Assert that Logger.error() not called & use sinon.match

* Add a manual delay in test

* Stub Logger.info() and Logger.trace() to log outputs

* Don't stub/spy twice & only test windows patch

* Fix non-working windows paste patch test

* Rename function to `applyWindowsPastePatch`

* Increase timeout for windows paste patch test

* Try to use python3 instead of python

* Also inject Node.js exec() method for tests

* Remove Emoji in Python patch to avoid encoding issues

* Detect python in venv correctly on Windows & use `.exe`

* Also call `python.exe` instead of just `python` in tests

* Fix typo in windows paste patch

* Log output of `exec()` in pipeline

* Log separate groups of exec output

* Print patch command to console

* Get rid of \r in patch file for exec()

* Also escape backslashes

* Base64-encode/decode to get rid of nasty escape errors

* Get rid of console logs & run all tests

* Use color in Mocha TTY

* Do some final cleanup

Author: Splines

.vscode/settings.json

@@ -94,6 +94,7 @@
     "ipython",
     "Keybord",
     "kisak",
+    "laggy",
     "libglut",
     "libpango",
     "Logfile",

package-lock.json

@@ -263,12 +263,14 @@
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^2.12.1",
+    "@types/chai": "^5.0.1",
     "@types/node": "^22.10.2",
     "@types/sinon": "^17.0.3",
     "@types/vscode": "^1.96.0",
     "@typescript-eslint/parser": "^8.18.2",
     "@vscode/test-cli": "^0.0.10",
     "@vscode/test-electron": "^2.4.1",
+    "chai": "^5.1.2",
     "eslint": "^9.17.0",
     "glob": "^11.0.0",
     "globals": "^15.14.0",

package.json

@@ -1,4 +1,3 @@
-import * as path from "path";
 import * as vscode from "vscode";
 import { window } from "vscode";
 import { ManimShell, NoActiveShellError } from "./manimShell";
@@ -12,6 +11,8 @@ import { ExportSceneCodeLens } from "./export";
 import { tryToDetermineManimVersion, LAST_WARNING_NO_VERSION_KEY } from "./manimVersion";
 import { setupTestEnvironment } from "./utils/testing";
 import { EventEmitter } from "events";
+import { applyWindowsPastePatch } from "./patches/applyPatches";
+import { getBinaryPathInPythonEnv } from "./utils/venv";
 
 export let manimNotebookContext: vscode.ExtensionContext;
 class WaitingForPythonExtensionCancelled extends Error {}
@@ -49,23 +50,33 @@ export async function activate(context: vscode.ExtensionContext) {
       await vscode.commands.executeCommand("workbench.action.openWalkthrough",
         `${context.extension.id}#manim-notebook-walkthrough`, false);
     });
-
   context.subscriptions.push(openWalkthroughCommand);
 
-  let manimglPath: string | undefined = undefined;
+  let pythonEnvPath: string | undefined = undefined;
   try {
-    manimglPath = await waitForPythonExtension();
+    pythonEnvPath = await waitForPythonExtension();
   } catch (err) {
     if (err instanceof WaitingForPythonExtensionCancelled) {
       Logger.info("💠 Waiting for Python extension cancelled, therefore"
         + " we cancel the extension activation");
       return;
     }
   }
-  if (manimglPath) {
-    manimglPath = pythonEnvToManimglPath(manimglPath);
+
+  if (process.platform === "win32") {
+    // Note that we shouldn't call `python3` on Windows,
+    // see https://github.com/Manim-Notebook/manim-notebook/pull/117#discussion_r1932764875
+    const pythonPath = pythonEnvPath
+      ? getBinaryPathInPythonEnv(pythonEnvPath, "python.exe")
+      : "python";
+    // not necessary to await here, can run in background
+    applyWindowsPastePatch(context, pythonPath);
   }
-  await tryToDetermineManimVersion(manimglPath);
+
+  const manimglBinary = pythonEnvPath
+    ? getBinaryPathInPythonEnv(pythonEnvPath, "manimgl")
+    : "manimgl";
+  await tryToDetermineManimVersion(manimglBinary);
 
   const previewManimCellCommand = vscode.commands.registerCommand(
     "manim-notebook.previewManimCell", (cellCode?: string, startLine?: number) => {
@@ -135,7 +146,7 @@ export async function activate(context: vscode.ExtensionContext) {
   const redetectManimVersionCommand = vscode.commands.registerCommand(
     "manim-notebook.redetectManimVersion", async () => {
       Logger.info("💠 Command requested: Redetect Manim Version");
-      await tryToDetermineManimVersion();
+      await tryToDetermineManimVersion("manimgl");
     });
 
   registerWalkthroughCommands(context);
@@ -205,22 +216,6 @@ async function waitForPythonExtension(): Promise<string | undefined> {
   });
 }
 
-/**
- * Transforms a path pointing to either an environment folder or a
- * Python executable into a path pointing to the ManimGL binary.
- *
- * @param path The path to the Python environment or Python executable.
- * @returns The path to the ManimGL binary.
- */
-function pythonEnvToManimglPath(envPath: string): string {
-  if (envPath.endsWith("python") || envPath.endsWith("python3")) {
-    return envPath.replace(/python3?$/, "manimgl");
-  } else {
-    const binFolderName = process.platform === "win32" ? "Scripts" : "bin";
-    return path.join(envPath, binFolderName, "manimgl");
-  }
-}
-
 /**
  * A global event emitter that can be used to listen for the extension being
  * activated. This is only used for testing purposes.

src/extension.ts

@@ -19,15 +19,6 @@ const IPYTHON_CELL_START_REGEX = /^\s*In \[\d+\]:/gm;
  */
 const LOG_INFO_MESSAGE_REGEX = /^\s*\[.*\] INFO/m;
 
-/**
- * Regular expression to match IPython multiline input "...:"
- * Sometimes IPython does not execute code when entering a newline, but enters a
- * multiline input mode, where it expects another line of code. We detect that
- * this happens and send an extra newline to run the code
- * See: https://github.com/Manim-Notebook/manim-notebook/issues/18
- */
-const IPYTHON_MULTILINE_START_REGEX = /^\s*\.{3}:\s+$/m;
-
 /**
  * Regular expression to match a KeyboardInterrupt.
  */
@@ -326,9 +317,6 @@ export class ManimShell {
     startLine?: number,
     handler?: CommandExecutionEventHandler,
   ) {
-    // append ESC + ENTER to avoid IPython starting a multi-line input (#18)
-    command += "\x1b\x0d";
-
     Logger.debug(`🚀 Exec command: ${command}, waitUntilFinished=${waitUntilFinished}`
       + `, forceExecute=${forceExecute}, errorOnNoActiveShell=${errorOnNoActiveShell}`);
 
@@ -775,14 +763,6 @@ export class ManimShell {
             }
           }
 
-          if (this.isExecutingCommand && data.match(IPYTHON_MULTILINE_START_REGEX)) {
-            Logger.debug("💨 IPython multiline detected, sending extra newline");
-            // do not use shell integration here, as it might send a CTRL-C
-            // while the prompt is not finished yet
-            // \x7F deletes the extra line ("...:") from IPython
-            this.exec(this.activeShell, "\x7F", false);
-          }
-
           if (data.match(ERROR_REGEX)) {
             Logger.debug("🚨 Error in IPython cell detected");
             this.activeShell?.show();

src/manimShell.ts

@@ -68,7 +68,7 @@ export async function isAtLeastManimVersion(versionRequired: string): Promise<bo
         + " ManimGL version could not be determined.",
       determineAgainOption, "I don't care");
       if (answer === determineAgainOption) {
-        await tryToDetermineManimVersion();
+        await tryToDetermineManimVersion("manimgl");
       }
     }
   }
@@ -134,10 +134,10 @@ async function fetchLatestManimVersion(): Promise<string | undefined> {
 /**
  * Tries to determine the Manim version with the `manimgl --version` command.
  *
- * @param manimglPath The path to the ManimGL executable, e.g. in a virtual
+ * @param manimglBinary The path to the ManimGL executable, e.g. in a virtual
  * environment. If undefined, we assume that `manimgl` is in the PATH.
  */
-export async function tryToDetermineManimVersion(manimglPath: string | undefined = undefined) {
+export async function tryToDetermineManimVersion(manimglBinary: string) {
   MANIM_VERSION = undefined;
   let couldDetermineManimVersion = false;
   isCanceledByUser = false;
@@ -163,8 +163,7 @@ export async function tryToDetermineManimVersion(manimglPath: string | undefined
         Logger.info("🔒 Locking Manim welcome string detection");
 
         const timeoutPromise = constructTimeoutPromise(8000, progress, token);
-        const cmd = manimglPath ? `${manimglPath} --version` : "manimgl --version";
-        const versionPromise = lookForManimVersionString(terminal, cmd);
+        const versionPromise = lookForManimVersionString(terminal, `${manimglBinary} --version`);
         Promise.race([timeoutPromise, versionPromise])
           .then(couldResolveVersion => resolve(couldResolveVersion))
           .catch((err) => {
@@ -213,7 +212,7 @@ async function showNegativeUserVersionFeedback() {
   const errMessage = "Your ManimGL version could not be determined.";
   const answer = await Window.showErrorMessage(errMessage, tryAgainAnswer);
   if (answer === tryAgainAnswer) {
-    await tryToDetermineManimVersion();
+    await tryToDetermineManimVersion("manimgl");
   }
 }