feat: adds ability to detect Python virtual envs

Author: gnikit

package-lock.json

@@ -761,6 +761,7 @@
     "@typescript-eslint/parser": "^8.24.0",
     "@vscode/test-electron": "^2.4.1",
     "c8": "^10.1.3",
+    "copy-webpack-plugin": "^12.0.2",
     "eslint": "^9.20.1",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-jsdoc": "^50.2.2",

package.json

@@ -0,0 +1,21 @@
+import os
+import sysconfig
+
+
+def get_install_bin_dir() -> str:
+    """Get the path to the pip install directory for scripts (bin, Scripts).
+    Works for virtualenv, conda, and system installs.
+
+    Returns
+    -------
+    str
+        Path to the pip install directory for scripts (bin, Scripts).
+    """
+    if ("VIRTUAL_ENV" in os.environ) or ("CONDA_PREFIX" in os.environ):
+        return sysconfig.get_path("scripts")
+    else:
+        return sysconfig.get_path("scripts", f"{os.name}_user")
+
+
+if __name__ == "__main__":
+    print(get_install_bin_dir())

scripts/get_pip_bin_dir.py

@@ -6,12 +6,12 @@ import * as vscode from 'vscode';
 import which from 'which';
 
 import { Logger } from '../services/logging';
+import { spawnAsPromise } from '../util/shell';
 import {
   FORMATTERS,
   EXTENSION_ID,
   promptForMissingTool,
   getWholeFileRange,
-  spawnAsPromise,
   pathRelToAbs,
 } from '../util/tools';
 

src/format/provider.ts

@@ -21,14 +21,13 @@ import {
 import { Logger } from '../services/logging';
 import { GlobPaths } from '../util/glob-paths';
 import { arraysEqual } from '../util/helper';
+import { spawnAsPromise, shellTask } from '../util/shell';
 import {
   EXTENSION_ID,
   resolveVariables,
   promptForMissingTool,
   isFreeForm,
-  spawnAsPromise,
   isFortran,
-  shellTask,
 } from '../util/tools';
 
 import { GNULinter, GNUModernLinter, IntelLinter, LFortranLinter, NAGLinter } from './compilers';

src/lint/provider.ts

@@ -10,13 +10,13 @@ import { LanguageClient, LanguageClientOptions, ServerOptions } from 'vscode-lan
 
 import { RestartLS } from '../commands/commands';
 import { Logger } from '../services/logging';
+import { pipInstall } from '../util/python';
 import {
   EXTENSION_ID,
   FortranDocumentSelector,
   LS_NAME,
   isFortran,
   getOuterMostWorkspaceFolder,
-  pipInstall,
   resolveVariables,
 } from '../util/tools';
 

src/lsp/client.ts

@@ -9,7 +9,6 @@ interface IJupyterServerUri {
   baseUrl: string;
   token: string;
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   authorizationHeader: any; // JSON object for authorization header.
   expiration?: Date; // Date/time when header expires and should be refreshed.
   displayName: string;
@@ -46,5 +45,4 @@ enum ColumnType {
   Bool = 'bool',
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type IRowsResponse = any[];

src/util/ms-python-api/jupyter/types.ts

@@ -0,0 +1,82 @@
+'use strict';
+
+import * as path from 'path';
+
+import { extensions, Uri } from 'vscode';
+
+import { IExtensionApi, ResolvedEnvironment } from './ms-python-api/types';
+import { shellTask, spawnAsPromise } from './shell';
+
+/**
+ * Get Python path from the workspace or the system
+ *
+ * @param resource file, folder or workspace to search for python
+ * @returns string with path to python
+ */
+export async function getPythonPath(resource?: Uri): Promise<string> {
+  const pythonEnv = await getPythonEnvMS(resource);
+  if (pythonEnv) {
+    return pythonEnv.path;
+  }
+  return process.platform === 'win32' ? 'python' : 'python3';
+}
+
+/**
+ * Get path that pip installs binaries into.
+ * Useful, for when the path is not in the PATH environment variable.
+ *
+ * @param resource file, folder or workspace
+ * @returns string with path to pip
+ */
+export async function getPipBinDir(resource?: Uri): Promise<string> {
+  const py = await getPythonPath(resource);
+  const script = path.join(__dirname, 'scripts', 'get_pip_bin_dir.py');
+  const [stdout, stderr] = await spawnAsPromise(py, [script]);
+  if (stderr) {
+    throw new Error(stderr);
+  }
+  return stdout.trim();
+}
+
+/**
+ * A wrapper around a call to `pip` for installing external tools.
+ * Does not explicitly check if `pip` is installed.
+ *
+ * @param pyPackage name of python package in PyPi
+ */
+export async function pipInstall(pyPackage: string): Promise<string> {
+  const py = await getPythonPath();
+  const args = ['-m', 'pip', 'install', '--user', '--upgrade', pyPackage];
+  return await shellTask(py, args, `pip: ${pyPackage}`);
+}
+
+/**
+ * Get the active Python environment, if any, via the ms-python.python
+ * extension API.
+ *
+ * @param resource file/folder/workspace Uri or undefined
+ * @returns Path to the active Python environment or undefined
+ */
+export async function getPythonEnvMS(
+  resource?: Uri | undefined
+): Promise<ResolvedEnvironment | undefined> {
+  try {
+    const extension = extensions.getExtension('ms-python.python');
+    if (!extension) {
+      return undefined; // extension not installed
+    }
+    if (!extension.isActive) {
+      await extension.activate();
+    }
+    const pythonApi: IExtensionApi = extension.exports as IExtensionApi;
+    const activeEnv: ResolvedEnvironment = await pythonApi.environments.resolveEnvironment(
+      pythonApi.environments.getActiveEnvironmentPath(resource)
+    );
+    if (!activeEnv) {
+      return undefined; // no active environment, unlikely but possible
+    }
+    return activeEnv;
+  } catch (error) {
+    return undefined;
+  }
+}

src/util/python.ts

@@ -0,0 +1,73 @@
+'use strict';
+
+import * as cp from 'child_process';
+
+import * as vscode from 'vscode';
+
+export async function shellTask(command: string, args: string[], name: string): Promise<string> {
+  const task = new vscode.Task(
+    { type: 'shell' },
+    vscode.TaskScope.Workspace,
+    name,
+    'Modern Fortran',
+    new vscode.ShellExecution(command, args)
+  );
+  // Temporay fix to https://github.com/microsoft/vscode/issues/157756
+  (<vscode.Task>task).definition = { type: 'shell', command: command };
+  const execution = await vscode.tasks.executeTask(task);
+  return await new Promise<string>((resolve, reject) => {
+    const disposable = vscode.tasks.onDidEndTaskProcess(e => {
+      if (e.execution === execution) {
+        disposable.dispose();
+        if (e.exitCode !== 0) {
+          reject(`ERROR: ${e.execution.task.name} failed with code ${e.exitCode}`);
+        }
+        resolve(`${name}: shell task completed successfully.`);
+      }
+    });
+  });
+}
+
+/**
+ * Spawn a command as a `Promise`
+ * @param cmd command to execute
+ * @param args arguments to pass to the command
+ * @param options child_process.spawn options
+ * @param input any input to pass to stdin
+ * @param ignoreExitCode ignore the exit code of the process and `resolve` the promise
+ * @returns Tuple[string, string] `[stdout, stderr]`. By default will `reject` if exit code is non-zero.
+ */
+export async function spawnAsPromise(
+  cmd: string,
+  args: ReadonlyArray<string> | undefined,
+  options?: cp.SpawnOptions | undefined,
+  input?: string | undefined,
+  ignoreExitCode?: boolean
+) {
+  return new Promise<[string, string]>((resolve, reject) => {
+    let stdout = '';
+    let stderr = '';
+    const child = cp.spawn(cmd, args, options);
+    child.stdout.on('data', data => {
+      stdout += data;
+    });
+    child.stderr.on('data', data => {
+      stderr += data;
+    });
+    child.on('close', code => {
+      if (ignoreExitCode || code === 0) {
+        resolve([stdout, stderr]);
+      } else {
+        reject([stdout, stderr]);
+      }
+    });
+    child.on('error', err => {
+      reject(err.toString());
+    });
+
+    if (input) {
+      child.stdin.write(input);
+      child.stdin.end();
+    }
+  });
+}