Finalizing design of proposed API for python environments

src/client/apiTypes.ts

@@ -1,11 +1,11 @@
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
 import { Event, Uri } from 'vscode';
 import { Resource } from './common/types';
 import { IDataViewerDataProvider, IJupyterUriProvider } from './jupyter/types';
-import { EnvPathType, PythonEnvKind } from './pythonEnvironments/base/info';
-import { GetRefreshEnvironmentsOptions, ProgressNotificationEvent } from './pythonEnvironments/base/locator';
 
 /*
  * Do not introduce any breaking changes to this API.
@@ -88,137 +88,3 @@ export interface IExtensionApi {
         registerRemoteServerProvider(serverProvider: IJupyterUriProvider): void;
     };
 }
-
-export interface EnvironmentDetailsOptions {
-    useCache: boolean;
-}
-
-export interface EnvironmentDetails {
-    interpreterPath: string;
-    envFolderPath?: string;
-    version: string[];
-    environmentType: PythonEnvKind[];
-    metadata: Record<string, unknown>;
-}
-
-export interface EnvironmentsChangedParams {
-    /**
-     * Path to environment folder or path to interpreter that uniquely identifies an environment.
-     * Virtual environments lacking an interpreter are identified by environment folder paths,
-     * whereas other envs can be identified using interpreter path.
-     */
-    path?: string;
-    type: 'add' | 'remove' | 'update' | 'clear-all';
-}
-
-export interface ActiveEnvironmentChangedParams {
-    /**
-     * Path to environment folder or path to interpreter that uniquely identifies an environment.
-     * Virtual environments lacking an interpreter are identified by environment folder paths,
-     * whereas other envs can be identified using interpreter path.
-     */
-    path: string;
-    resource?: Uri;
-}
-
-export interface IProposedExtensionAPI {
-    environment: {
-        /**
-         * An event that is emitted when execution details (for a resource) change. For instance, when interpreter configuration changes.
-         */
-        readonly onDidChangeExecutionDetails: Event<Uri | undefined>;
-        /**
-         * Returns all the details the consumer needs to execute code within the selected environment,
-         * corresponding to the specified resource taking into account any workspace-specific settings
-         * for the workspace to which this resource belongs.
-         * @param {Resource} [resource] A resource for which the setting is asked for.
-         * * When no resource is provided, the setting scoped to the first workspace folder is returned.
-         * * If no folder is present, it returns the global setting.
-         * @returns {({ execCommand: string[] | undefined })}
-         */
-        getExecutionDetails(
-            resource?: Resource,
-        ): Promise<{
-            /**
-             * E.g of execution commands returned could be,
-             * * `['<path to the interpreter set in settings>']`
-             * * `['<path to the interpreter selected by the extension when setting is not set>']`
-             * * `['conda', 'run', 'python']` which is used to run from within Conda environments.
-             * or something similar for some other Python environments.
-             *
-             * @type {(string[] | undefined)} When return value is `undefined`, it means no interpreter is set.
-             * Otherwise, join the items returned using space to construct the full execution command.
-             */
-            execCommand: string[] | undefined;
-        }>;
-        /**
-         * Returns the path to the python binary selected by the user or as in the settings.
-         * This is just the path to the python binary, this does not provide activation or any
-         * other activation command. The `resource` if provided will be used to determine the
-         * python binary in a multi-root scenario. If resource is `undefined` then the API
-         * returns what ever is set for the workspace.
-         * @param resource : Uri of a file or workspace
-         */
-        getActiveEnvironmentPath(resource?: Resource): Promise<EnvPathType | undefined>;
-        /**
-         * Returns details for the given interpreter. Details such as absolute interpreter path,
-         * version, type (conda, pyenv, etc). Metadata such as `sysPrefix` can be found under
-         * metadata field.
-         * @param path : Full path to environment folder or interpreter whose details you need.
-         * @param options : [optional]
-         *     * useCache : When true, cache is checked first for any data, returns even if there
-         *                  is partial data.
-         */
-        getEnvironmentDetails(
-            path: string,
-            options?: EnvironmentDetailsOptions,
-        ): Promise<EnvironmentDetails | undefined>;
-        /**
-         * Returns paths to environments that uniquely identifies an environment found by the extension
-         * at the time of calling. This API will *not* trigger a refresh. If a refresh is going on it
-         * will *not* wait for the refresh to finish. This will return what is known so far. To get
-         * complete list `await` on promise returned by `getRefreshPromise()`.
-         *
-         * Virtual environments lacking an interpreter are identified by environment folder paths,
-         * whereas other envs can be identified using interpreter path.
-         */
-        getEnvironmentPaths(): Promise<EnvPathType[] | undefined>;
-        /**
-         * Sets the active environment path for the python extension for the resource. Configuration target
-         * will always be the workspace folder.
-         * @param path : Full path to environment folder or interpreter to set.
-         * @param resource : [optional] Uri of a file ro workspace to scope to a particular workspace
-         *                   folder.
-         */
-        setActiveEnvironment(path: string, resource?: Resource): Promise<void>;
-        /**
-         * This API will re-trigger environment discovery. Extensions can wait on the returned
-         * promise to get the updated environment list. If there is a refresh already going on
-         * then it returns the promise for that refresh.
-         * @param options : [optional]
-         *     * clearCache : When true, this will clear the cache before environment refresh
-         *                    is triggered.
-         */
-        refreshEnvironment(): Promise<EnvPathType[] | undefined>;
-        /**
-         * Tracks discovery progress for current list of known environments, i.e when it starts, finishes or any other relevant
-         * stage. Note the progress for a particular query is currently not tracked or reported, this only indicates progress of
-         * the entire collection.
-         */
-        readonly onRefreshProgress: Event<ProgressNotificationEvent>;
-        /**
-         * Returns a promise for the ongoing refresh. Returns `undefined` if there are no active
-         * refreshes going on.
-         */
-        getRefreshPromise(options?: GetRefreshEnvironmentsOptions): Promise<void> | undefined;
-        /**
-         * This event is triggered when the known environment list changes, like when a environment
-         * is found, existing environment is removed, or some details changed on an environment.
-         */
-        onDidEnvironmentsChanged: Event<EnvironmentsChangedParams[]>;
-        /**
-         * This event is triggered when the active environment changes.
-         */
-        onDidActiveEnvironmentChanged: Event<ActiveEnvironmentChangedParams>;
-    };
-}

src/client/extension.ts

@@ -42,10 +42,11 @@ import { sendErrorTelemetry, sendStartupTelemetry } from './startupTelemetry';
 import { IStartupDurations } from './types';
 import { runAfterActivation } from './common/utils/runAfterActivation';
 import { IInterpreterService } from './interpreter/contracts';
-import { IExtensionApi, IProposedExtensionAPI } from './apiTypes';
+import { IExtensionApi } from './apiTypes';
 import { buildProposedApi } from './proposedApi';
 import { WorkspaceService } from './common/application/workspace';
 import { disposeAll } from './common/utils/resourceLifecycle';
+import { IProposedExtensionAPI } from './proposedApiTypes';
 
 durations.codeLoadingTime = stopWatch.elapsedTime;
 

src/client/interpreter/interpreterService.ts

@@ -11,7 +11,7 @@ import {
     Uri,
 } from 'vscode';
 import '../common/extensions';
-import { IApplicationShell, IDocumentManager } from '../common/application/types';
+import { IApplicationShell, IDocumentManager, IWorkspaceService } from '../common/application/types';
 import {
     IConfigurationService,
     IDisposableRegistry,
@@ -221,8 +221,8 @@ export class InterpreterService implements Disposable, IInterpreterService {
             this._pythonPathSetting = pySettings.pythonPath;
             this.didChangeInterpreterEmitter.fire();
             reportActiveInterpreterChanged({
-                path: pySettings.pythonPath,
-                resource,
+                pathID: pySettings.pythonPath,
+                resource: this.serviceContainer.get<IWorkspaceService>(IWorkspaceService).getWorkspaceFolder(resource),
             });
             const interpreterDisplay = this.serviceContainer.get<IInterpreterDisplay>(IInterpreterDisplay);
             interpreterDisplay.refresh().catch((ex) => traceError('Python Extension: display.refresh', ex));

src/client/proposedApi.ts

@@ -2,17 +2,17 @@
 // Licensed under the MIT License.
 
 import { ConfigurationTarget, EventEmitter } from 'vscode';
-import {
-    ActiveEnvironmentChangedParams,
-    EnvironmentDetails,
-    EnvironmentDetailsOptions,
-    EnvironmentsChangedParams,
-    IProposedExtensionAPI,
-} from './apiTypes';
 import { arePathsSame } from './common/platform/fs-paths';
 import { IInterpreterPathService, Resource } from './common/types';
 import { IInterpreterService } from './interpreter/contracts';
 import { IServiceContainer } from './ioc/types';
+import {
+    EnvironmentsChangedParams,
+    ActiveEnvironmentChangedParams,
+    IProposedExtensionAPI,
+    EnvironmentDetailsOptions,
+    EnvironmentDetails,
+} from './proposedApiTypes';
 import { PythonEnvInfo } from './pythonEnvironments/base/info';
 import { getEnvPath } from './pythonEnvironments/base/info/env';
 import { GetRefreshEnvironmentsOptions, IDiscoveryAPI } from './pythonEnvironments/base/locator';
@@ -32,7 +32,7 @@ function getVersionString(env: PythonEnvInfo): string[] {
     if (env.version.release) {
         ver.push(`${env.version.release}`);
         if (env.version.sysVersion) {
-            ver.push(`${env.version.release}`);
+            ver.push(`${env.version.sysVersion}`);
         }
     }
     return ver;