refactor: half-baked Python config implementation

Author: gnikit

package.json

@@ -394,7 +394,7 @@
         "properties": {
           "fortran.fortls.path": {
             "type": "string",
-            "default": "fortls",
+            "default": "",
             "markdownDescription": "Path to the Fortran language server (`fortls`).",
             "order": 10
           },

scripts/get_console_script.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import sys
+import pkg_resources
+
+
+def get_console_script_path(package_name: str, script_name: str) -> str | None:
+    # """
+    # Get the absolute path of a console script from a package.
+
+    # @param package_name: The name of the package.
+    # @param script_name: The name of the console script.
+    # @return The absolute path of the console script.
+    # """
+    try:
+        # Get the distribution object for the package
+        dist = pkg_resources.get_distribution(package_name)
+        # Get the entry point for the console script
+        entry_point = dist.get_entry_info("console_scripts", script_name)
+        # Get the path to the script
+        script_path = entry_point.module_name.split(":")[0]
+        # Return the absolute path of the script
+        return pkg_resources.resource_filename(dist, script_path)
+    except Exception as e:
+        # Handle any exceptions that occur
+        print(f"Error: {e}")
+        return None
+
+
+print(get_console_script_path(sys.argv[1], sys.argv[2]))

scripts/mod_in_env.py

@@ -0,0 +1,8 @@
+#! /usr/bin/env python3
+
+import sys
+import pkg_resources
+
+# If not present, fails with a DistributionNotFound exception
+if pkg_resources.get_distribution(str(sys.argv[1])).version:
+    exit(0)

src/lsp/client.ts

@@ -10,7 +10,7 @@ import { LanguageClient, LanguageClientOptions, ServerOptions } from 'vscode-lan
 
 import { RestartLS } from '../commands/commands';
 import { Logger } from '../services/logging';
-import { pipInstall } from '../util/python';
+import { Python } from '../util/python';
 import {
   EXTENSION_ID,
   FortranDocumentSelector,
@@ -26,11 +26,16 @@ import {
 export const clients: Map<string, LanguageClient> = new Map();
 
 export class FortlsClient {
+  private readonly python: Python;
+  private readonly config: vscode.WorkspaceConfiguration;
+
   constructor(
     private logger: Logger,
     private context?: vscode.ExtensionContext
   ) {
     this.logger.debug('[lsp.client] Fortran Language Server -- constructor');
+    this.python = new Python();
+    this.config = workspace.getConfiguration(EXTENSION_ID);
 
     // if context is present
     if (context !== undefined) {
@@ -316,6 +321,7 @@ export class FortlsClient {
     const ls = await this.fortlsPath();
 
     // Check for version, if this fails fortls provided is invalid
+    const pipBin: string = await this.python.getPipBinDir();
     const results = spawnSync(ls, ['--version']);
     const msg = `It is highly recommended to use the fortls to enable IDE features like hover, peeking, GoTos and many more. 
       For a full list of features the language server adds see: https://fortls.fortran-lang.org`;
@@ -326,7 +332,7 @@ export class FortlsClient {
           if (opt === 'Install') {
             try {
               this.logger.info(`[lsp.client] Downloading ${LS_NAME}`);
-              const msg = await pipInstall(LS_NAME);
+              const msg = await this.python.pipInstall(LS_NAME);
               window.showInformationMessage(msg);
               this.logger.info(`[lsp.client] ${LS_NAME} installed`);
               resolve(false);
@@ -378,19 +384,38 @@ export class FortlsClient {
     const root = folder ? getOuterMostWorkspaceFolder(folder).uri : vscode.Uri.parse(os.homedir());
 
     const config = workspace.getConfiguration(EXTENSION_ID);
-    let executablePath = resolveVariables(config.get<string>('fortls.path'));
+    // TODO: make the default value undefined, make windows use fortls.exe
+    // get the full path of the Python bin dir, check if file exists
+    // else we are running a script with  a relative path (verify this is the case)
+    let executablePath = config.get<string>('fortls.path');
+    if (!executablePath || this.isFortlsPathDefault(executablePath)) {
+      executablePath = 'fortls' + (os.platform() === 'win32' ? '.exe' : '');
+      executablePath = path.join(await this.python.getPipBinDir(), executablePath);
+    } else {
+      executablePath = resolveVariables(executablePath);
+    }
 
     // The path can be resolved as a relative path if:
     // 1. it does not have the default value `fortls` AND
     // 2. is not an absolute path
-    if (executablePath !== 'fortls' && !path.isAbsolute(executablePath)) {
+    if (!path.isAbsolute(executablePath)) {
       this.logger.debug(`[lsp.client] Assuming relative fortls path is to ${root.fsPath}`);
       executablePath = path.join(root.fsPath, executablePath);
     }
 
     return executablePath;
   }
 
+  private async isFortlsPathDefault(path: string): Promise<boolean> {
+    if (path === 'fortls') {
+      return true;
+    }
+    if (os.platform() === 'win32' && path === 'fortls.exe') {
+      return true;
+    }
+    return false;
+  }
+
   /**
    * Restart the language server
    */

src/util/python-config.ts

@@ -0,0 +1,8 @@
+'use strict';
+
+import { Uri } from 'vscode';
+
+import { Python } from './python';
+
+// TODO: implement interface and config
+export class PythonConfiguration {}

src/util/python.ts

@@ -1,82 +1,100 @@
-'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';
-}
+export class Python {
+  public readonly path: Promise<string>;
+  private usingMSPython = false;
+  private pythonEnvMS: ResolvedEnvironment | undefined;
 
-/**
- * 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);
+  constructor(resource?: Uri) {
+    this.path = this.getPythonPath(resource);
   }
-  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 path to the active Python interpreter.
+   *
+   * @returns The path to the active Python interpreter.
+   */
+  public async getPythonPath(resource?: Uri): Promise<string> {
+    const pythonEnv = await this.getPythonEnvMS(resource);
+    if (pythonEnv) {
+      this.usingMSPython = true;
+      return pythonEnv.path;
+    }
+    return process.platform === 'win32' ? 'python' : 'python3';
+  }
 
-/**
- * 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
+  /**
+   * Get the path to the directory where pip installs binaries.
+   *
+   * @returns The path to the directory where pip installs binaries.
+   */
+  public async getPipBinDir(): Promise<string> {
+    const py = await this.path;
+    const script = path.join(__dirname, 'scripts', 'get_pip_bin_dir.py');
+    const [stdout, stderr] = await spawnAsPromise(py, [script]);
+    if (stderr) {
+      throw new Error(stderr);
     }
-    if (!extension.isActive) {
-      await extension.activate();
+    return stdout.trim();
+  }
+
+  /**
+   * Install a Python package using pip.
+   *
+   * @param packageName The name of the package to install.
+   * @returns The output of the pip command.
+   */
+  public async pipInstall(packageName: string): Promise<string> {
+    const py = await this.path;
+    const args = ['-m', 'pip', 'install', '--user', '--upgrade', packageName];
+    return await shellTask(py, args, `pip: ${packageName}`);
+  }
+
+  /**
+   * Get the active Python environment, if any, via the ms-python.python
+   * extension API.
+   *
+   * @returns The active Python environment, or undefined if there is none.
+   */
+  public async getPythonEnvMS(resource?: Uri): 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
+      }
+      this.pythonEnvMS = activeEnv;
+      return activeEnv;
+    } catch (error) {
+      return undefined;
     }
-    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
+  }
+
+  public async isInstalled(packageName: string): Promise<boolean> {
+    const py = await this.path;
+    const script = path.join(__dirname, 'scripts', 'mod_in_env.py');
+    try {
+      const [_, stderr] = await spawnAsPromise(py, [script, packageName]);
+      if (stderr) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      return false;
     }
-    return activeEnv;
-  } catch (error) {
-    return undefined;
   }
 }

src/util/tools.ts

@@ -5,7 +5,7 @@ import * as path from 'path';
 import * as vscode from 'vscode';
 
 import { isString, isArrayOfString } from './helper';
-import { pipInstall } from './python';
+import { Python } from './python';
 
 export const LS_NAME = 'fortls';
 export const EXTENSION_ID = 'fortran';
@@ -119,7 +119,8 @@ export async function promptForMissingTool(
     if (selected === 'Install') {
       if (toolType === 'Python') {
         try {
-          const inst_msg = await pipInstall(tool);
+          const python = new Python();
+          const inst_msg = await python.pipInstall(tool);
           vscode.window.showInformationMessage(inst_msg);
         } catch (error) {
           vscode.window.showErrorMessage(error);

webpack.config.js

@@ -28,7 +28,10 @@ const config = {
   },
   plugins: [
     new CopyWebpackPlugin({
-      patterns: [{ from: 'scripts/get_pip_bin_dir.py', to: 'scripts/get_pip_bin_dir.py' }],
+      patterns: [
+        { from: 'scripts/get_pip_bin_dir.py', to: 'scripts/get_pip_bin_dir.py' },
+        { from: 'scripts/mod_in_env.py', to: 'scripts/mod_in_env.py' },
+      ],
     }),
   ],
   module: {