Added environments reducer

Author: Kartik Raj

src/client/pythonEnvironments/base/locator.ts

@@ -92,7 +92,7 @@ export type PythonLocatorQuery = BasicPythonLocatorQuery & {
     searchLocations?: Uri[];
 };
 
-type QueryForEvent<E> = E extends PythonEnvsChangedEvent ? PythonLocatorQuery : BasicPythonLocatorQuery;
+export type QueryForEvent<E> = E extends PythonEnvsChangedEvent ? PythonLocatorQuery : BasicPythonLocatorQuery;
 
 /**
  * A single Python environment locator.

src/client/pythonEnvironments/environmentsReducer.ts

@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { Event, EventEmitter } from 'vscode';
+import { createDeferredFrom, Deferred } from '../common/utils/async';
+import { PythonEnvInfo } from './base/info';
+import {
+    ILocator, IPythonEnvsIterator, PythonEnvUpdatedEvent, QueryForEvent,
+} from './base/locator';
+import { BasicPythonEnvsChangedEvent, PythonEnvsChangedEvent } from './base/watcher';
+import { mergeEnvironments } from './info';
+
+export class PythonEnvsReducer<E extends BasicPythonEnvsChangedEvent = PythonEnvsChangedEvent> implements ILocator {
+    public get onChanged(): Event<E> {
+        return this.didChange.event;
+    }
+
+    private readonly environmentsReceived: Map<string, PythonEnvInfo> = new Map<string, PythonEnvInfo>();
+
+    private readonly didChange = new EventEmitter<E>();
+
+    constructor(private readonly pythonEnvsManager: ILocator) {}
+
+    public iterEnvs(
+        query?: QueryForEvent<E>,
+    ): IPythonEnvsIterator {
+        const didUpdate = new EventEmitter<PythonEnvUpdatedEvent | null>();
+        return { ...this.iterEnvsIterator(didUpdate, query), onUpdated: didUpdate.event };
+    }
+
+    public resolveEnv(env: string | PythonEnvInfo): Promise<PythonEnvInfo | undefined> {
+        return this.pythonEnvsManager.resolveEnv(env);
+    }
+
+    private async* iterEnvsIterator(
+        didUpdate: EventEmitter<PythonEnvUpdatedEvent | null>,
+        query?: QueryForEvent<E>,
+    ): AsyncIterator<PythonEnvInfo, void> {
+        const deferreds: Deferred<void>[] = [];
+        const iterator = this.pythonEnvsManager.iterEnvs(query);
+        let result = await iterator.next();
+        while (!result.done) {
+            const currEnv = result.value;
+            if (this.environmentsReceived.has(currEnv.id)) {
+                // Resolve differences in the background
+                const resolveDifferences = async () => {
+                    const storedEnv = this.environmentsReceived.get(currEnv.id)!;
+                    const resolvedEnv = mergeEnvironments([currEnv, storedEnv])[0];
+                    didUpdate.fire({ old: currEnv, new: resolvedEnv });
+                };
+                const promise = resolveDifferences();
+                // Carries all the promises ongoing in background
+                deferreds.push(createDeferredFrom(promise));
+                this.checkIfFinishedAndNotify({ allItemsIterated: !!result.done, deferreds }, didUpdate);
+            } else {
+                yield currEnv;
+            }
+            this.environmentsReceived.set(currEnv.id, currEnv);
+            // eslint-disable-next-line no-await-in-loop
+            result = await iterator.next();
+        }
+        this.checkIfFinishedAndNotify({ allItemsIterated: result.done, deferreds }, didUpdate);
+    }
+
+    /**
+     * When all items are iterated and all background calls finishes, notify that we're done
+     * @param state Carries the current state of progress
+     * @param didUpdate Used to notify when finished
+     */
+    private checkIfFinishedAndNotify(
+        state: {
+            allItemsIterated: boolean,
+            // Carries all the promises ongoing in background
+            deferreds: Deferred<void>[]
+        },
+        didUpdate: EventEmitter<PythonEnvUpdatedEvent | null>,
+    ) {
+        if (state.deferreds.length === 0) {
+            return;
+        }
+        state.deferreds = state.deferreds.filter((item) => !item.completed);
+        if (state.deferreds.length === 0 && state.allItemsIterated) {
+            didUpdate.fire(null);
+            didUpdate.dispose();
+        }
+        Promise.all(state.deferreds.map((item) => item.promise))
+            .then(() => this.checkIfFinishedAndNotify(state, didUpdate))
+            .ignoreErrors();
+    }
+}

src/client/pythonEnvironments/info/index.ts

@@ -7,6 +7,7 @@ import * as path from 'path';
 import * as semver from 'semver';
 import { IFileSystem } from '../../common/platform/types';
 import { Architecture } from '../../common/utils/platform';
+import { PythonEnvInfo } from '../base/info';
 import { areSameVersion, PythonVersion } from './pythonVersion';
 
 /**
@@ -124,7 +125,7 @@ export function getEnvironmentTypeName(environmentType: EnvironmentType) {
 export function areSameEnvironment(
     environment1: PartialPythonEnvironment | undefined,
     environment2: PartialPythonEnvironment | undefined,
-    fs: IFileSystem,
+    fs: IFileSystem
 ): boolean {
     if (!environment1 || !environment2) {
         return false;
@@ -163,7 +164,7 @@ export function updateEnvironment(environment: PartialPythonEnvironment, other:
         'architecture',
         'sysVersion',
         'version',
-        'pipEnvWorkspaceFolder',
+        'pipEnvWorkspaceFolder'
     ];
     props.forEach((prop) => {
         if (!environment[prop] && other[prop]) {
@@ -172,6 +173,16 @@ export function updateEnvironment(environment: PartialPythonEnvironment, other:
         }
     });
 }
+/**
+ * Combine env info for matching environments.
+ *
+ * Environments are matched by path and version.
+ *
+ * @param environments - the env infos to merge
+ */
+export function mergeEnvironments(environments: PythonEnvInfo[]): PythonEnvInfo[] {
+    return environments;
+}
 
 /**
  * Combine env info for matching environments.
@@ -180,9 +191,9 @@ export function updateEnvironment(environment: PartialPythonEnvironment, other:
  *
  * @param environments - the env infos to merge
  */
-export function mergeEnvironments(
+export function mergeEnvironmentsOld(
     environments: PartialPythonEnvironment[],
-    fs: IFileSystem,
+    fs: IFileSystem
 ): PartialPythonEnvironment[] {
     return environments.reduce<PartialPythonEnvironment[]>((accumulator, current) => {
         const existingItem = accumulator.find((item) => areSameEnvironment(current, item, fs));