Move code related to Python version to the py-envs component tree. (#12236)

This mostly involves moving code, and only minor refactoring (to pull the component code out of the DI-based classes).

Author: ericsnowcurrently

pythonFiles/interpreterInfo.py

@@ -5,7 +5,7 @@
 import sys
 
 obj = {}
-obj["versionInfo"] = sys.version_info[:4]
+obj["versionInfo"] = tuple(sys.version_info)
 obj["sysPrefix"] = sys.prefix
 obj["version"] = sys.version
 obj["is64Bit"] = sys.maxsize > 2 ** 32

pythonFiles/vscode_datascience_helpers/daemon/daemon_python.py

@@ -198,7 +198,7 @@ def m_get_executable(self):
 
     def m_get_interpreter_information(self):
         return {
-            "versionInfo": sys.version_info[:4],
+            "versionInfo": tuple(sys.version_info),
             "sysPrefix": sys.prefix,
             "version": sys.version,
             "is64Bit": sys.maxsize > 2 ** 32,

src/client/common/process/internal/scripts/index.ts

@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 
 import * as path from 'path';
-import { PythonVersionInfo } from '../../../../pythonEnvironments/discovery/types';
 import { EXTENSION_ROOT_DIR } from '../../../constants';
 
 // It is simpler to hard-code it instead of using vscode.ExtensionContext.extensionPath.
@@ -41,7 +40,9 @@ export * as vscode_datascience_helpers from './vscode_datascience_helpers';
 //============================
 // interpreterInfo.py
 
-type PythonEnvInfo = {
+type ReleaseLevel = 'alpha' | 'beta' | 'candidate' | 'final';
+type PythonVersionInfo = [number, number, number, ReleaseLevel, number];
+export type PythonEnvInfo = {
     versionInfo: PythonVersionInfo;
     sysPrefix: string;
     sysVersion: string;

src/client/common/process/pythonDaemon.ts

@@ -5,16 +5,16 @@
 
 import { ChildProcess } from 'child_process';
 import { MessageConnection, RequestType, RequestType0 } from 'vscode-jsonrpc';
-import { InterpreterInformation, PythonVersionInfo } from '../../pythonEnvironments/discovery/types';
+import { InterpreterInformation } from '../../pythonEnvironments/discovery/types';
+import { PythonExecInfo } from '../../pythonEnvironments/exec';
+import { extractInterpreterInfo } from '../../pythonEnvironments/info';
 import { traceWarning } from '../logger';
-import { Architecture } from '../utils/platform';
-import { parsePythonVersion } from '../utils/version';
 import { BasePythonDaemon } from './baseDaemon';
+import { PythonEnvInfo } from './internal/scripts';
 import {
     IPythonDaemonExecutionService,
     IPythonExecutionService,
     ObservableExecutionResult,
-    PythonExecutionInfo,
     SpawnOptions
 } from './types';
 
@@ -43,25 +43,12 @@ export class PythonDaemonExecutionService extends BasePythonDaemon implements IP
     public async getInterpreterInformation(): Promise<InterpreterInformation | undefined> {
         try {
             this.throwIfRPCConnectionIsDead();
-            type InterpreterInfoResponse = ErrorResponse & {
-                versionInfo: PythonVersionInfo;
-                sysPrefix: string;
-                sysVersion: string;
-                is64Bit: boolean;
-            };
-            const request = new RequestType0<InterpreterInfoResponse, void, void>('get_interpreter_information');
+            const request = new RequestType0<PythonEnvInfo & ErrorResponse, void, void>('get_interpreter_information');
             const response = await this.sendRequestWithoutArgs(request);
-            const versionValue =
-                response.versionInfo.length === 4
-                    ? `${response.versionInfo.slice(0, 3).join('.')}-${response.versionInfo[3]}`
-                    : response.versionInfo.join('.');
-            return {
-                architecture: response.is64Bit ? Architecture.x64 : Architecture.x86,
-                path: this.pythonPath,
-                version: parsePythonVersion(versionValue),
-                sysVersion: response.sysVersion,
-                sysPrefix: response.sysPrefix
-            };
+            if (response.error) {
+                throw Error(response.error);
+            }
+            return extractInterpreterInfo(this.pythonPath, response);
         } catch (ex) {
             traceWarning('Falling back to Python Execution Service due to failure in daemon', ex);
             return this.pythonExecutionService.getInterpreterInformation();
@@ -82,7 +69,7 @@ export class PythonDaemonExecutionService extends BasePythonDaemon implements IP
             return this.pythonExecutionService.getExecutablePath();
         }
     }
-    public getExecutionInfo(pythonArgs?: string[]): PythonExecutionInfo {
+    public getExecutionInfo(pythonArgs?: string[]): PythonExecInfo {
         return this.pythonExecutionService.getExecutionInfo(pythonArgs);
     }
     public async isModuleInstalled(moduleName: string): Promise<boolean> {

src/client/common/process/pythonDaemonPool.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 import { InterpreterInformation } from '../../pythonEnvironments/discovery/types';
+import { PythonExecInfo } from '../../pythonEnvironments/exec';
 import { IDisposableRegistry } from '../types';
 import { sleep } from '../utils/async';
 import { noop } from '../utils/misc';
@@ -17,7 +18,6 @@ import {
     isDaemonPoolCreationOption,
     ObservableExecutionResult,
     PooledDaemonExecutionFactoryCreationOptions,
-    PythonExecutionInfo,
     SpawnOptions
 } from './types';
 
@@ -68,7 +68,7 @@ export class PythonDaemonExecutionServicePool extends PythonDaemonFactory implem
         const msg = { args: ['getExecutablePath'] };
         return this.wrapCall((daemon) => daemon.getExecutablePath(), msg);
     }
-    public getExecutionInfo(pythonArgs?: string[]): PythonExecutionInfo {
+    public getExecutionInfo(pythonArgs?: string[]): PythonExecInfo {
         return this.pythonExecutionService.getExecutionInfo(pythonArgs);
     }
     public async isModuleInstalled(moduleName: string): Promise<boolean> {

src/client/common/process/pythonEnvironment.ts

@@ -3,19 +3,13 @@
 
 import { CondaEnvironmentInfo } from '../../pythonEnvironments/discovery/locators/services/conda';
 import { InterpreterInformation } from '../../pythonEnvironments/discovery/types';
+import { getPythonExecInfo, PythonExecInfo } from '../../pythonEnvironments/exec';
+import { extractInterpreterInfo } from '../../pythonEnvironments/info';
 import { traceError, traceInfo } from '../logger';
 import { IFileSystem } from '../platform/types';
-import { Architecture } from '../utils/platform';
-import { parsePythonVersion } from '../utils/version';
 import * as internalPython from './internal/python';
 import * as internalScripts from './internal/scripts';
-import { ExecutionResult, IProcessService, PythonExecutionInfo, ShellOptions, SpawnOptions } from './types';
-
-function getExecutionInfo(python: string[], pythonArgs: string[]): PythonExecutionInfo {
-    const args = python.slice(1);
-    args.push(...pythonArgs);
-    return { command: python[0], args, python };
-}
+import { ExecutionResult, IProcessService, ShellOptions, SpawnOptions } from './types';
 
 class PythonEnvironment {
     private cachedInterpreterInformation: InterpreterInformation | undefined | null = null;
@@ -33,13 +27,13 @@ class PythonEnvironment {
         }
     ) {}
 
-    public getExecutionInfo(pythonArgs: string[] = []): PythonExecutionInfo {
+    public getExecutionInfo(pythonArgs: string[] = []): PythonExecInfo {
         const python = this.deps.getPythonArgv(this.pythonPath);
-        return getExecutionInfo(python, pythonArgs);
+        return getPythonExecInfo(python, pythonArgs);
     }
-    public getExecutionObservableInfo(pythonArgs: string[] = []): PythonExecutionInfo {
+    public getExecutionObservableInfo(pythonArgs: string[] = []): PythonExecInfo {
         const python = this.deps.getObservablePythonArgv(this.pythonPath);
-        return getExecutionInfo(python, pythonArgs);
+        return getPythonExecInfo(python, pythonArgs);
     }
 
     public async getInterpreterInformation(): Promise<InterpreterInformation | undefined> {
@@ -96,17 +90,7 @@ class PythonEnvironment {
             }
             const json = parse(result.stdout);
             traceInfo(`Found interpreter for ${argv}`);
-            const versionValue =
-                json.versionInfo.length === 4
-                    ? `${json.versionInfo.slice(0, 3).join('.')}-${json.versionInfo[3]}`
-                    : json.versionInfo.join('.');
-            return {
-                architecture: json.is64Bit ? Architecture.x64 : Architecture.x86,
-                path: this.pythonPath,
-                version: parsePythonVersion(versionValue),
-                sysVersion: json.sysVersion,
-                sysPrefix: json.sysPrefix
-            };
+            return extractInterpreterInfo(this.pythonPath, json);
         } catch (ex) {
             traceError(`Failed to get interpreter information for '${this.pythonPath}'`, ex);
         }

src/client/common/process/pythonProcess.ts

@@ -1,25 +1,20 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+import { PythonExecInfo } from '../../pythonEnvironments/exec';
 import { ErrorUtils } from '../errors/errorUtils';
 import { ModuleNotInstalledError } from '../errors/moduleNotInstalledError';
 import * as internalPython from './internal/python';
-import {
-    ExecutionResult,
-    IProcessService,
-    ObservableExecutionResult,
-    PythonExecutionInfo,
-    SpawnOptions
-} from './types';
+import { ExecutionResult, IProcessService, ObservableExecutionResult, SpawnOptions } from './types';
 
 class PythonProcessService {
     constructor(
         // This is the externally defined functionality used by the class.
         private readonly deps: {
             // from PythonEnvironment:
             isModuleInstalled(moduleName: string): Promise<boolean>;
-            getExecutionInfo(pythonArgs?: string[]): PythonExecutionInfo;
-            getExecutionObservableInfo(pythonArgs?: string[]): PythonExecutionInfo;
+            getExecutionInfo(pythonArgs?: string[]): PythonExecInfo;
+            getExecutionObservableInfo(pythonArgs?: string[]): PythonExecInfo;
             // from ProcessService:
             exec(file: string, args: string[], options: SpawnOptions): Promise<ExecutionResult<string>>;
             execObservable(file: string, args: string[], options: SpawnOptions): ObservableExecutionResult<string>;
@@ -75,8 +70,8 @@ export function createPythonProcessService(
     procs: IProcessService,
     // from PythonEnvironment:
     env: {
-        getExecutionInfo(pythonArgs?: string[]): PythonExecutionInfo;
-        getExecutionObservableInfo(pythonArgs?: string[]): PythonExecutionInfo;
+        getExecutionInfo(pythonArgs?: string[]): PythonExecInfo;
+        getExecutionObservableInfo(pythonArgs?: string[]): PythonExecInfo;
         isModuleInstalled(moduleName: string): Promise<boolean>;
     }
 ) {

src/client/common/process/types.ts

@@ -7,6 +7,7 @@ import { CancellationToken, Uri } from 'vscode';
 
 import { Newable } from '../../ioc/types';
 import { InterpreterInformation, PythonInterpreter } from '../../pythonEnvironments/discovery/types';
+import { PythonExecInfo } from '../../pythonEnvironments/exec';
 import { ExecutionInfo, IDisposable } from '../types';
 import { EnvironmentVariables } from '../variables/types';
 
@@ -167,7 +168,7 @@ export interface IPythonExecutionService {
     getInterpreterInformation(): Promise<InterpreterInformation | undefined>;
     getExecutablePath(): Promise<string>;
     isModuleInstalled(moduleName: string): Promise<boolean>;
-    getExecutionInfo(pythonArgs?: string[]): PythonExecutionInfo;
+    getExecutionInfo(pythonArgs?: string[]): PythonExecInfo;
 
     execObservable(args: string[], options: SpawnOptions): ObservableExecutionResult<string>;
     execModuleObservable(moduleName: string, args: string[], options: SpawnOptions): ObservableExecutionResult<string>;
@@ -176,12 +177,6 @@ export interface IPythonExecutionService {
     execModule(moduleName: string, args: string[], options: SpawnOptions): Promise<ExecutionResult<string>>;
 }
 
-export type PythonExecutionInfo = {
-    command: string;
-    args: string[];
-
-    python: string[];
-};
 /**
  * Identical to the PythonExecutionService, but with a `dispose` method.
  * This is a daemon process that lives on until it is disposed, hence the `IDisposable`.

src/client/common/utils/version.ts

@@ -4,7 +4,6 @@
 'use strict';
 
 import * as semver from 'semver';
-import { Version } from '../types';
 
 export function parseVersion(raw: string): semver.SemVer {
     raw = raw.replace(/\.00*(?=[1-9]|0\.)/, '.');
@@ -16,32 +15,3 @@ export function parseVersion(raw: string): semver.SemVer {
     }
     return ver;
 }
-export function parsePythonVersion(version: string): Version | undefined {
-    if (!version || version.trim().length === 0) {
-        return;
-    }
-    const versionParts = (version || '')
-        .split('.')
-        .map((item) => item.trim())
-        .filter((item) => item.length > 0)
-        .filter((_, index) => index < 4);
-
-    if (versionParts.length > 0 && versionParts[versionParts.length - 1].indexOf('-') > 0) {
-        const lastPart = versionParts[versionParts.length - 1];
-        versionParts[versionParts.length - 1] = lastPart.split('-')[0].trim();
-        versionParts.push(lastPart.split('-')[1].trim());
-    }
-    while (versionParts.length < 4) {
-        versionParts.push('');
-    }
-    // Exclude PII from `version_info` to ensure we don't send this up via telemetry.
-    for (let index = 0; index < 3; index += 1) {
-        versionParts[index] = /^\d+$/.test(versionParts[index]) ? versionParts[index] : '0';
-    }
-    if (['alpha', 'beta', 'candidate', 'final'].indexOf(versionParts[3]) === -1) {
-        versionParts.pop();
-    }
-    const numberParts = `${versionParts[0]}.${versionParts[1]}.${versionParts[2]}`;
-    const rawVersion = versionParts.length === 4 ? `${numberParts}-${versionParts[3]}` : numberParts;
-    return new semver.SemVer(rawVersion);
-}

src/client/interpreter/interpreterVersion.ts

@@ -2,22 +2,22 @@ import { inject, injectable } from 'inversify';
 import '../common/extensions';
 import * as internalPython from '../common/process/internal/python';
 import { IProcessServiceFactory } from '../common/process/types';
+import { getPythonVersion } from '../pythonEnvironments/pythonVersion';
 import { IInterpreterVersionService } from './contracts';
 
 export const PIP_VERSION_REGEX = '\\d+\\.\\d+(\\.\\d+)?';
 
 @injectable()
 export class InterpreterVersionService implements IInterpreterVersionService {
     constructor(@inject(IProcessServiceFactory) private readonly processServiceFactory: IProcessServiceFactory) {}
+
     public async getVersion(pythonPath: string, defaultValue: string): Promise<string> {
-        const [args, parse] = internalPython.getVersion();
         const processService = await this.processServiceFactory.create();
-        return processService
-            .exec(pythonPath, args, { mergeStdOutErr: true })
-            .then((output) => parse(output.stdout).splitLines()[0])
-            .then((version) => (version.length === 0 ? defaultValue : version))
-            .catch(() => defaultValue);
+        return getPythonVersion(pythonPath, defaultValue, (cmd, args) =>
+            processService.exec(cmd, args, { mergeStdOutErr: true })
+        );
     }
+
     public async getPipVersion(pythonPath: string): Promise<string> {
         const [args, parse] = internalPython.getModuleVersion('pip');
         const processService = await this.processServiceFactory.create();

src/client/pythonEnvironments/discovery/locators/services/windowsRegistryService.ts

@@ -7,10 +7,10 @@ import { traceError } from '../../../../common/logger';
 import { IFileSystem, IPlatformService, IRegistry, RegistryHive } from '../../../../common/platform/types';
 import { IPathUtils } from '../../../../common/types';
 import { Architecture } from '../../../../common/utils/platform';
-import { parsePythonVersion } from '../../../../common/utils/version';
 import { IInterpreterHelper } from '../../../../interpreter/contracts';
 import { IWindowsStoreInterpreter } from '../../../../interpreter/locators/types';
 import { IServiceContainer } from '../../../../ioc/types';
+import { parsePythonVersion } from '../../../pythonVersion';
 import { InterpreterType, PythonInterpreter } from '../../types';
 import { CacheableLocatorService } from './cacheableLocatorService';
 import { AnacondaCompanyName, AnacondaCompanyNames } from './conda';

src/client/pythonEnvironments/exec.ts

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+export type PythonExecInfo = {
+    command: string;
+    args: string[];
+
+    python: string[];
+};
+
+export function getPythonExecInfo(python: string | string[], pythonArgs?: string[]): PythonExecInfo {
+    if (Array.isArray(python)) {
+        const args = python.slice(1);
+        if (pythonArgs) {
+            args.push(...pythonArgs);
+        }
+        return { command: python[0], args, python };
+    } else {
+        return { command: python, args: pythonArgs || [], python: [python] };
+    }
+}

src/client/pythonEnvironments/info.ts

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { PythonEnvInfo } from '../common/process/internal/scripts';
+import { Architecture } from '../common/utils/platform';
+import { InterpreterInformation } from './discovery/types';
+import { parsePythonVersion } from './pythonVersion';
+
+export function extractInterpreterInfo(python: string, raw: PythonEnvInfo): InterpreterInformation {
+    const rawVersion = `${raw.versionInfo.slice(0, 3).join('.')}-${raw.versionInfo[3]}`;
+    return {
+        architecture: raw.is64Bit ? Architecture.x64 : Architecture.x86,
+        path: python,
+        version: parsePythonVersion(rawVersion),
+        sysVersion: raw.sysVersion,
+        sysPrefix: raw.sysPrefix
+    };
+}