import {  * A single update to a previously provided Python env object.  */ export type PythonEnvUpdatedEvent = {+    /**+     * The iteration index of The env info that was previously provided.+     */+    index: number;     /**      * The env info that was previously provided.-     *-     * If the event comes from `IPythonEnvsIterator.onUpdated` then-     * `old` was previously yielded during iteration.      */-    old: PythonEnvInfo;+    old?: PythonEnvInfo;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { Uri } from 'vscode';+import { createDeferred } from '../../common/utils/async';+import { getURIFilter } from '../../common/utils/misc';+import { PythonEnvInfo } from './info';+import {+    IPythonEnvsIterator,+    PythonEnvUpdatedEvent,+    PythonLocatorQuery,+} from './locator';++/**+ * Create a filter function to match the given query.+ */+export function getQueryFilter(query: PythonLocatorQuery): (env: PythonEnvInfo) => boolean {+    const kinds = (query.kinds !== undefined && query.kinds.length > 0)+        ? query.kinds+        : undefined;+    let includeGlobal = !query.searchLocations || query.searchLocations.length === 0;+    let locationFilters: ((u: Uri) => boolean)[] | undefined;+    if (!includeGlobal) {+        const candidates = query.searchLocations!.filter((u) => !!u);+        includeGlobal = candidates.length < query.searchLocations!.length;+        if (candidates.length > 0) {+            locationFilters = candidates.map((loc) => getURIFilter(loc!, {+                checkParent: true,+                checkExact: true,

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { Uri } from 'vscode';+import { createDeferred } from '../../common/utils/async';+import { getURIFilter } from '../../common/utils/misc';+import { PythonEnvInfo } from './info';+import {+    IPythonEnvsIterator,+    PythonEnvUpdatedEvent,+    PythonLocatorQuery,+} from './locator';++/**+ * Create a filter function to match the given query.+ */+export function getQueryFilter(query: PythonLocatorQuery): (env: PythonEnvInfo) => boolean {+    const kinds = (query.kinds !== undefined && query.kinds.length > 0)+        ? query.kinds+        : undefined;+    let includeNonRooted = true;+    if (query.searchLocations !== undefined) {+        if (query.searchLocations.includeNonRooted !== undefined) {+            includeNonRooted = query.searchLocations.includeNonRooted;+        } else {+            // We default to `false`.+            includeNonRooted = false;+        }+    }+    const locationFilters = getSearchLocationFilters(query);+    function checkKind(env: PythonEnvInfo): boolean {+        if (kinds === undefined) {+            return true;+        }+        return kinds.includes(env.kind);+    }+    function checkSearchLocation(env: PythonEnvInfo): boolean {+        if (env.searchLocation === undefined) {+            // It is not a "rooted" env.+            return includeNonRooted;+        } else {+            // It is a "rooted" env.+            if (locationFilters === undefined) {+                return query.searchLocations === undefined;+            }+            // Check against the requested roots.+            return locationFilters.some((filter) => filter(env.searchLocation!));+        }+    }+    return (env) => {+        if (!checkKind(env)) {+            return false;+        }+        if (!checkSearchLocation(env)) {+            return false;+        }+        return true;+    };+}++function getSearchLocationFilters(query: PythonLocatorQuery): ((u: Uri) => boolean)[] | undefined {+    if (query.searchLocations === undefined) {+        return undefined;+    }+    const candidates: Uri[] = query.searchLocations.roots.filter((u) => !!u);+    if (candidates.length === 0) {+        return undefined;+    }

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { Uri } from 'vscode';+import { createDeferred } from '../../common/utils/async';+import { getURIFilter } from '../../common/utils/misc';+import { PythonEnvInfo } from './info';+import {+    IPythonEnvsIterator,+    PythonEnvUpdatedEvent,+    PythonLocatorQuery,+} from './locator';++/**+ * Create a filter function to match the given query.+ */+export function getQueryFilter(query: PythonLocatorQuery): (env: PythonEnvInfo) => boolean {+    const kinds = (query.kinds !== undefined && query.kinds.length > 0)+        ? query.kinds+        : undefined;+    let includeNonRooted = true;+    if (query.searchLocations !== undefined) {+        if (query.searchLocations.includeNonRooted !== undefined) {+            includeNonRooted = query.searchLocations.includeNonRooted;+        } else {+            // We default to `false`.+            includeNonRooted = false;+        }+    }+    const locationFilters = getSearchLocationFilters(query);+    function checkKind(env: PythonEnvInfo): boolean {+        if (kinds === undefined) {+            return true;+        }+        return kinds.includes(env.kind);+    }+    function checkSearchLocation(env: PythonEnvInfo): boolean {+        if (env.searchLocation === undefined) {+            // It is not a "rooted" env.+            return includeNonRooted;+        } else {+            // It is a "rooted" env.+            if (locationFilters === undefined) {+                return query.searchLocations === undefined;+            }+            // Check against the requested roots.+            return locationFilters.some((filter) => filter(env.searchLocation!));+        }+    }+    return (env) => {+        if (!checkKind(env)) {+            return false;+        }+        if (!checkSearchLocation(env)) {+            return false;+        }+        return true;+    };+}++function getSearchLocationFilters(query: PythonLocatorQuery): ((u: Uri) => boolean)[] | undefined {+    if (query.searchLocations === undefined) {+        return undefined;+    }+    const candidates: Uri[] = query.searchLocations.roots.filter((u) => !!u);

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { Uri } from 'vscode';+import { createDeferred } from '../../common/utils/async';+import { getURIFilter } from '../../common/utils/misc';+import { PythonEnvInfo } from './info';+import {+    IPythonEnvsIterator,+    PythonEnvUpdatedEvent,+    PythonLocatorQuery,+} from './locator';++/**+ * Create a filter function to match the given query.+ */+export function getQueryFilter(query: PythonLocatorQuery): (env: PythonEnvInfo) => boolean {+    const kinds = (query.kinds !== undefined && query.kinds.length > 0)+        ? query.kinds+        : undefined;+    let includeNonRooted = true;+    if (query.searchLocations !== undefined) {+        if (query.searchLocations.includeNonRooted !== undefined) {+            includeNonRooted = query.searchLocations.includeNonRooted;+        } else {+            // We default to `false`.+            includeNonRooted = false;+        }+    }+    const locationFilters = getSearchLocationFilters(query);+    function checkKind(env: PythonEnvInfo): boolean {+        if (kinds === undefined) {+            return true;+        }+        return kinds.includes(env.kind);+    }+    function checkSearchLocation(env: PythonEnvInfo): boolean {+        if (env.searchLocation === undefined) {+            // It is not a "rooted" env.+            return includeNonRooted;+        } else {+            // It is a "rooted" env.+            if (locationFilters === undefined) {+                return query.searchLocations === undefined;+            }+            // Check against the requested roots.+            return locationFilters.some((filter) => filter(env.searchLocation!));+        }+    }+    return (env) => {+        if (!checkKind(env)) {+            return false;+        }+        if (!checkSearchLocation(env)) {+            return false;+        }+        return true;+    };+}++function getSearchLocationFilters(query: PythonLocatorQuery): ((u: Uri) => boolean)[] | undefined {+    if (query.searchLocations === undefined) {+        return undefined;+    }+    const candidates: Uri[] = query.searchLocations.roots.filter((u) => !!u);

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { Uri } from 'vscode';+import { createDeferred } from '../../common/utils/async';+import { getURIFilter } from '../../common/utils/misc';+import { PythonEnvInfo } from './info';+import {+    IPythonEnvsIterator,+    PythonEnvUpdatedEvent,+    PythonLocatorQuery,+} from './locator';++/**+ * Create a filter function to match the given query.+ */+export function getQueryFilter(query: PythonLocatorQuery): (env: PythonEnvInfo) => boolean {+    const kinds = (query.kinds !== undefined && query.kinds.length > 0)+        ? query.kinds+        : undefined;+    let includeNonRooted = true;+    if (query.searchLocations !== undefined) {+        if (query.searchLocations.includeNonRooted !== undefined) {+            includeNonRooted = query.searchLocations.includeNonRooted;+        } else {+            // We default to `false`.+            includeNonRooted = false;+        }+    }+    const locationFilters = getSearchLocationFilters(query);+    function checkKind(env: PythonEnvInfo): boolean {+        if (kinds === undefined) {+            return true;+        }+        return kinds.includes(env.kind);+    }+    function checkSearchLocation(env: PythonEnvInfo): boolean {+        if (env.searchLocation === undefined) {+            // It is not a "rooted" env.+            return includeNonRooted;+        } else {+            // It is a "rooted" env.+            if (locationFilters === undefined) {+                return query.searchLocations === undefined;+            }+            // Check against the requested roots.+            return locationFilters.some((filter) => filter(env.searchLocation!));+        }+    }+    return (env) => {+        if (!checkKind(env)) {+            return false;+        }+        if (!checkSearchLocation(env)) {+            return false;+        }+        return true;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { Architecture } from '../../../common/utils/platform';++import {+    PythonEnvInfo,+    PythonEnvKind,+    PythonReleaseLevel,+    PythonVersion,+} from '.';++/**+ * Create a new info object with all values empty.+ *+ * @param init - if provided, these values are applied to the new object+ */+export function buildEnvInfo(init?: {+    kind?: PythonEnvKind;+    executable?: string;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { Uri } from 'vscode';+import { createDeferred } from '../../common/utils/async';+import { getURIFilter } from '../../common/utils/misc';+import { PythonEnvInfo } from './info';+import {+    IPythonEnvsIterator,+    PythonEnvUpdatedEvent,+    PythonLocatorQuery,+} from './locator';++/**+ * Create a filter function to match the given query.+ */+export function getQueryFilter(query: PythonLocatorQuery): (env: PythonEnvInfo) => boolean {+    const kinds = (query.kinds !== undefined && query.kinds.length > 0)+        ? query.kinds+        : undefined;+    let includeGlobal = !query.searchLocations || query.searchLocations.length === 0;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { Uri } from 'vscode';+import { createDeferred } from '../../common/utils/async';+import { getURIFilter } from '../../common/utils/misc';+import { PythonEnvInfo } from './info';+import {+    IPythonEnvsIterator,+    PythonEnvUpdatedEvent,+    PythonLocatorQuery,+} from './locator';++/**+ * Create a filter function to match the given query.+ */+export function getQueryFilter(query: PythonLocatorQuery): (env: PythonEnvInfo) => boolean {+    const kinds = (query.kinds !== undefined && query.kinds.length > 0)+        ? query.kinds+        : undefined;+    let includeGlobal = !query.searchLocations || query.searchLocations.length === 0;+    let locationFilters: ((u: Uri) => boolean)[] | undefined;+    if (!includeGlobal) {+        const candidates = query.searchLocations!.filter((u) => !!u);+        includeGlobal = candidates.length < query.searchLocations!.length;+        if (candidates.length > 0) {+            locationFilters = candidates.map((loc) => getURIFilter(loc!, {+                checkParent: true,+                checkExact: true,

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { Uri } from 'vscode';+import { createDeferred } from '../../common/utils/async';+import { getURIFilter } from '../../common/utils/misc';+import { PythonEnvInfo } from './info';+import {+    IPythonEnvsIterator,+    PythonEnvUpdatedEvent,+    PythonLocatorQuery,+} from './locator';++/**+ * Create a filter function to match the given query.+ */+export function getQueryFilter(query: PythonLocatorQuery): (env: PythonEnvInfo) => boolean {+    const kinds = (query.kinds !== undefined && query.kinds.length > 0)+        ? query.kinds+        : undefined;+    let includeGlobal = !query.searchLocations || query.searchLocations.length === 0;+    let locationFilters: ((u: Uri) => boolean)[] | undefined;+    if (!includeGlobal) {+        const candidates = query.searchLocations!.filter((u) => !!u);

 export type BasicPythonLocatorQuery = {  * emitted by watchers.  *  * @prop - searchLocations - if provided, results should be limited to- *         within these locations+ *         within these locations; `null` means "include envs that have+ *         no search location"  */ export type PythonLocatorQuery = BasicPythonLocatorQuery & {-    searchLocations?: Uri[];+    searchLocations?: (Uri | null)[] | null;

 export type BasicPythonLocatorQuery = {  * emitted by watchers.  *  * @prop - searchLocations - if provided, results should be limited to- *         within these locations+ *         within these locations; `null` means "include envs that have+ *         no search location"  */ export type PythonLocatorQuery = BasicPythonLocatorQuery & {-    searchLocations?: Uri[];+    searchLocations?: (Uri | null)[] | null;

 export type BasicPythonLocatorQuery = {  * emitted by watchers.  *  * @prop - searchLocations - if provided, results should be limited to- *         within these locations+ *         within these locations; `null` means "include envs that have+ *         no search location"  */ export type PythonLocatorQuery = BasicPythonLocatorQuery & {-    searchLocations?: Uri[];+    searchLocations?: (Uri | null)[] | null;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { Uri } from 'vscode';+import { createDeferred } from '../../common/utils/async';+import { getURIFilter } from '../../common/utils/misc';+import { PythonEnvInfo } from './info';+import {+    IPythonEnvsIterator,+    PythonEnvUpdatedEvent,+    PythonLocatorQuery,+} from './locator';++/**+ * Create a filter function to match the given query.+ */+export function getQueryFilter(query: PythonLocatorQuery): (env: PythonEnvInfo) => boolean {+    const kinds = (query.kinds !== undefined && query.kinds.length > 0)+        ? query.kinds+        : undefined;+    let includeGlobal = !query.searchLocations || query.searchLocations.length === 0;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { Uri } from 'vscode';+import { createDeferred } from '../../common/utils/async';+import { getURIFilter } from '../../common/utils/misc';+import { PythonEnvInfo } from './info';+import {+    IPythonEnvsIterator,+    PythonEnvUpdatedEvent,+    PythonLocatorQuery,+} from './locator';++/**+ * Create a filter function to match the given query.+ */+export function getQueryFilter(query: PythonLocatorQuery): (env: PythonEnvInfo) => boolean {+    const kinds = (query.kinds !== undefined && query.kinds.length > 0)+        ? query.kinds+        : undefined;+    let includeGlobal = !query.searchLocations || query.searchLocations.length === 0;+    let locationFilters: ((u: Uri) => boolean)[] | undefined;+    if (!includeGlobal) {+        const candidates = query.searchLocations!.filter((u) => !!u);+        includeGlobal = candidates.length < query.searchLocations!.length;+        if (candidates.length > 0) {+            locationFilters = candidates.map((loc) => getURIFilter(loc!, {+                checkParent: true,+                checkExact: true,+            }));+        }+    }+    function checkKind(env: PythonEnvInfo): boolean {+        if (kinds === undefined) {+            return true;+        }+        return kinds.includes(env.kind);+    }+    function checkSearchLocation(env: PythonEnvInfo): boolean {+        if (env.searchLocation === undefined) {+            // It is not a "rooted" env.+            return includeGlobal;+        }++        // It is a "rooted" env.+        if (locationFilters === undefined) {

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { Uri } from 'vscode';+import { createDeferred } from '../../common/utils/async';+import { getURIFilter } from '../../common/utils/misc';+import { PythonEnvInfo } from './info';+import {+    IPythonEnvsIterator,+    PythonEnvUpdatedEvent,+    PythonLocatorQuery,+} from './locator';++/**+ * Create a filter function to match the given query.+ */+export function getQueryFilter(query: PythonLocatorQuery): (env: PythonEnvInfo) => boolean {+    const kinds = (query.kinds !== undefined && query.kinds.length > 0)+        ? query.kinds+        : undefined;+    let includeGlobal = !query.searchLocations || query.searchLocations.length === 0;+    let locationFilters: ((u: Uri) => boolean)[] | undefined;+    if (!includeGlobal) {+        const candidates = query.searchLocations!.filter((u) => !!u);+        includeGlobal = candidates.length < query.searchLocations!.length;+        if (candidates.length > 0) {+            locationFilters = candidates.map((loc) => getURIFilter(loc!, {+                checkParent: true,+                checkExact: true,

 export type BasicPythonLocatorQuery = {  * emitted by watchers.  *  * @prop - searchLocations - if provided, results should be limited to- *         within these locations+ *         within these locations; `null` means "include envs that have+ *         no search location"  */ export type PythonLocatorQuery = BasicPythonLocatorQuery & {-    searchLocations?: Uri[];+    searchLocations?: (Uri | null)[] | null;

+// Copyright (c) Microsoft Corporation. All rights reserved.++import { PythonVersion } from '.';++// Licensed under the MIT License.+export function areSameVersion(left: PythonVersion, right:PythonVersion): boolean {

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');+        this.envsList = this.persistentStorage?.value;+    }++    public getAllEnvs(): PythonEnvInfo[] | undefined {+        return this.envsList;+    }++    public setAllEnvs(envs: PythonEnvInfo[]): void {+        this.envsList = cloneDeep(envs);+    }++    public getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined {+        // Retrieve all keys with non-undefined values.+        type EnvParamKeys = keyof typeof env;+        const keys = (Object.keys(env) as unknown as EnvParamKeys[]).filter((key) => env[key] !== undefined);++        // Return the first object where the values match env's.+        return this.envsList?.find((info) => {+            // Check if there is any mismatch between the values of the in-memory info and env.+            const mismatch = keys.some((key) => info[key] !== env[key]);++            return !mismatch;+        });+    }

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');+        this.envsList = this.persistentStorage?.value;+    }++    public getAllEnvs(): PythonEnvInfo[] | undefined {+        return this.envsList;+    }++    public setAllEnvs(envs: PythonEnvInfo[]): void {+        this.envsList = cloneDeep(envs);+    }++    public getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined {+        // Retrieve all keys with non-undefined values.+        type EnvParamKeys = keyof typeof env;+        const keys = (Object.keys(env) as unknown as EnvParamKeys[]).filter((key) => env[key] !== undefined);++        // Return the first object where the values match env's.+        return this.envsList?.find((info) => {+            // Check if there is any mismatch between the values of the in-memory info and env.+            const mismatch = keys.some((key) => info[key] !== env[key]);++            return !mismatch;+        });+    }

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;

 export class PythonEnvironments implements ILocator {  */ export function createAPI(): [PythonEnvironments, () => void] {     const [locators, activateLocators] = initLocators();+    // Update this to pass in an actual function that checks for env info completeness.+    const envsCache = new PythonEnvInfoCache(() => true);

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');+        this.envsList = this.persistentStorage?.value;+    }++    public getAllEnvs(): PythonEnvInfo[] | undefined {+        return this.envsList;+    }++    public setAllEnvs(envs: PythonEnvInfo[]): void {+        this.envsList = cloneDeep(envs);+    }++    public getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined {+        // Retrieve all keys with non-undefined values.+        type EnvParamKeys = keyof typeof env;+        const keys = (Object.keys(env) as unknown as EnvParamKeys[]).filter((key) => env[key] !== undefined);++        // Return the first object where the values match env's.+        return this.envsList?.find((info) => {+            // Check if there is any mismatch between the values of the in-memory info and env.+            const mismatch = keys.some((key) => info[key] !== env[key]);++            return !mismatch;+        });+    }

 export function arePathsSame(path1: string, path2: string): boolean {     }     return path1 === path2; }++function getPersistentStateFactory(): IPersistentStateFactory {+    return internalServiceContainer.get<IPersistentStateFactory>(IPersistentStateFactory);+}++export function createGlobalPersistentStore<T>(key: string): IPersistentState<T> {+    const factory = getPersistentStateFactory();++    return factory.createGlobalPersistentState<T>(key, undefined);+}

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');+        this.envsList = this.persistentStorage?.value;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;

+// Copyright (c) Microsoft Corporation. All rights reserved.

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { cloneDeep } from 'lodash';
+import { Event, EventEmitter } from 'vscode';
+import { traceVerbose } from '../../common/logger';
+import { areSameEnvironment, PythonEnvInfo } from '../base/info';
+import { InterpreterInformation } from '../base/info/interpreter';
+import {
+    ILocator, IPythonEnvsIterator, PythonEnvUpdatedEvent, PythonLocatorQuery,
+} from '../base/locator';
+import { PythonEnvsChangedEvent } from '../base/watcher';
+import { IEnvironmentInfoService } from '../info/environmentInfoService';
+
+export class PythonEnvsResolver implements ILocator {

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { cloneDeep } from 'lodash';
+import { Event, EventEmitter } from 'vscode';
+import { traceVerbose } from '../../common/logger';
+import { areSameEnvironment, PythonEnvInfo } from '../base/info';
+import { InterpreterInformation } from '../base/info/interpreter';
+import {
+    ILocator, IPythonEnvsIterator, PythonEnvUpdatedEvent, PythonLocatorQuery,
+} from '../base/locator';
+import { PythonEnvsChangedEvent } from '../base/watcher';
+import { IEnvironmentInfoService } from '../info/environmentInfoService';
+
+export class PythonEnvsResolver implements ILocator {
+    public get onChanged(): Event<PythonEnvsChangedEvent> {
+        return this.parentLocator.onChanged;
+    }
+
+    constructor(
+        private readonly parentLocator: ILocator,
+        private readonly environmentInfoService: IEnvironmentInfoService,
+    ) {}
+
+    public async resolveEnv(env: string | PythonEnvInfo): Promise<PythonEnvInfo | undefined> {
+        const environment = await this.parentLocator.resolveEnv(env);
+        if (!environment) {
+            return undefined;
+        }
+        const interpreterInfo = await this.environmentInfoService.getEnvironmentInfo(environment.executable.filename);
+        if (!interpreterInfo) {
+            return undefined;
+        }
+        return getResolvedEnv(interpreterInfo, environment);
+    }
+
+    public iterEnvs(query?: PythonLocatorQuery): IPythonEnvsIterator {
+        const didUpdate = new EventEmitter<PythonEnvUpdatedEvent | null>();
+        const incomingIterator = this.parentLocator.iterEnvs(query);
+        const iterator: IPythonEnvsIterator = this.iterEnvsIterator(incomingIterator, didUpdate);
+        iterator.onUpdated = didUpdate.event;
+        return iterator;
+    }
+
+    private async* iterEnvsIterator(
+        iterator: IPythonEnvsIterator,
+        didUpdate: EventEmitter<PythonEnvUpdatedEvent | null>,
+    ): AsyncIterator<PythonEnvInfo, void> {
+        const state = {
+            done: false,
+            pending: 0,
+        };
+        const seen: PythonEnvInfo[] = [];
+
+        if (iterator.onUpdated !== undefined) {
+            iterator.onUpdated((event) => {
+                if (event === null) {
+                    state.done = true;
+                    checkIfFinishedAndNotify(state, didUpdate);
+                } else {
+                    const oldIndex = seen.findIndex((s) => areSameEnvironment(s, event.old));
+                    if (oldIndex !== -1) {
+                        seen[oldIndex] = event.new;
+                        state.pending += 1;
+                        this.resolveInBackground(oldIndex, state, didUpdate, seen).ignoreErrors();
+                    } else {
+                        // This implies a problem in a downstream locator
+                        traceVerbose(`Expected already iterated env in resolver, got ${event.old}`);
+                    }
+                }
+            });
+        }
+
+        let result = await iterator.next();
+        while (!result.done) {
+            const currEnv = result.value;
+            // Resolver only expects unique environments, so store & yield as-is.

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { cloneDeep } from 'lodash';
+import { Event, EventEmitter } from 'vscode';
+import { traceVerbose } from '../../common/logger';
+import { areSameEnvironment, PythonEnvInfo } from '../base/info';
+import { InterpreterInformation } from '../base/info/interpreter';
+import {
+    ILocator, IPythonEnvsIterator, PythonEnvUpdatedEvent, QueryForEvent,
+} from '../base/locator';
+import { PythonEnvsChangedEvent } from '../base/watcher';
+import { IEnvironmentInfoService } from '../info/environmentInfoService';
+
+export class PythonEnvsResolver implements ILocator {
+    public get onChanged(): Event<PythonEnvsChangedEvent> {
+        return this.pythonEnvsReducer.onChanged;
+    }
+
+    constructor(
+        private readonly pythonEnvsReducer: ILocator,
+        private readonly environmentInfoService: IEnvironmentInfoService,

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { assert, expect } from 'chai';
+import { cloneDeep } from 'lodash';
+import * as path from 'path';
+import { ImportMock } from 'ts-mock-imports';
+import { EventEmitter } from 'vscode';
+import { ExecutionResult } from '../../../client/common/process/types';
+import { Architecture } from '../../../client/common/utils/platform';
+import { PythonEnvInfo, PythonEnvKind } from '../../../client/pythonEnvironments/base/info';
+import { parseVersion } from '../../../client/pythonEnvironments/base/info/pythonVersion';
+import { PythonEnvUpdatedEvent } from '../../../client/pythonEnvironments/base/locator';
+import { PythonEnvsChangedEvent } from '../../../client/pythonEnvironments/base/watcher';
+import { PythonEnvsResolver } from '../../../client/pythonEnvironments/collection/environmentsResolver';
+import * as ExternalDep from '../../../client/pythonEnvironments/common/externalDependencies';
+import { EnvironmentInfoService } from '../../../client/pythonEnvironments/info/environmentInfoService';
+import { sleep } from '../../core';
+import { createEnv, getEnvs, SimpleLocator } from '../base/common';
+
+suite('Environments Resolver', () => {
+    /**
+     * Returns the expected environment to be returned by Environment info service
+     */
+    function createExpectedEnvInfo(env: PythonEnvInfo): PythonEnvInfo {
+        const updatedEnv = cloneDeep(env);
+        updatedEnv.version = {
+            ...parseVersion('3.8.3-final'),
+            sysVersion: '3.8.3 (tags/v3.8.3:6f8c832, May 13 2020, 22:37:02) [MSC v.1924 64 bit (AMD64)]',
+        };
+        updatedEnv.executable.filename = env.executable.filename;
+        updatedEnv.executable.sysPrefix = 'path';
+        updatedEnv.arch = Architecture.x64;
+        return updatedEnv;
+    }
+    suite('iterEnvs()', () => {
+        let stubShellExec: sinon.SinonStub;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');+        this.envsList = this.persistentStorage?.value;+    }++    public getAllEnvs(): PythonEnvInfo[] | undefined {+        return this.envsList;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');+        this.envsList = this.persistentStorage?.value;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');+        this.envsList = this.persistentStorage?.value;+    }++    public getAllEnvs(): PythonEnvInfo[] | undefined {+        return this.envsList;+    }++    public setAllEnvs(envs: PythonEnvInfo[]): void {+        this.envsList = cloneDeep(envs);+    }++    public getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined {+        // Retrieve all keys with non-undefined values.+        type EnvParamKeys = keyof typeof env;+        const keys = (Object.keys(env) as unknown as EnvParamKeys[]).filter((key) => env[key] !== undefined);++        // Return the first object where the values match env's.+        return this.envsList?.find((info) => {+            // Check if there is any mismatch between the values of the in-memory info and env.+            const mismatch = keys.some((key) => info[key] !== env[key]);++            return !mismatch;+        });+    }

 export function arePathsSame(path1: string, path2: string): boolean {     }     return path1 === path2; }++function getPersistentStateFactory(): IPersistentStateFactory {+    return internalServiceContainer.get<IPersistentStateFactory>(IPersistentStateFactory);+}++export function createGlobalPersistentStore<T>(key: string): IPersistentState<T> {+    const factory = getPersistentStateFactory();++    return factory.createGlobalPersistentState<T>(key, undefined);+}

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');+        this.envsList = this.persistentStorage?.value;+    }++    public getAllEnvs(): PythonEnvInfo[] | undefined {+        return this.envsList;+    }++    public setAllEnvs(envs: PythonEnvInfo[]): void {+        this.envsList = cloneDeep(envs);+    }++    public getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined {+        // Retrieve all keys with non-undefined values.+        type EnvParamKeys = keyof typeof env;+        const keys = (Object.keys(env) as unknown as EnvParamKeys[]).filter((key) => env[key] !== undefined);++        // Return the first object where the values match env's.+        return this.envsList?.find((info) => {

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import * as assert from 'assert';+import * as sinon from 'sinon';+import { CompleteEnvInfoFunction, PythonEnvInfoCache } from '../../../client/pythonEnvironments/base/envsCache';+import { PythonEnvInfo, PythonEnvKind } from '../../../client/pythonEnvironments/base/info';+import * as externalDeps from '../../../client/pythonEnvironments/common/externalDependencies';++suite('Environment Info cache', () => {+    let createGlobalPersistentStoreStub: sinon.SinonStub;+    let updatedValues: PythonEnvInfo[] | undefined;++    const allEnvsComplete: CompleteEnvInfoFunction = () => true;+    const envInfoArray = [+        {+            id: 'someid1', kind: PythonEnvKind.Conda, name: 'my-conda-env', defaultDisplayName: 'env-one',+        },+        {+            id: 'someid2', kind: PythonEnvKind.Venv, name: 'my-venv-env', defaultDisplayName: 'env-two',+        },+        {+            id: 'someid3', kind: PythonEnvKind.Pyenv, name: 'my-pyenv-env', defaultDisplayName: 'env-three',

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');+        this.envsList = this.persistentStorage?.value;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');+        this.envsList = this.persistentStorage?.value;+    }++    public getAllEnvs(): PythonEnvInfo[] | undefined {+        return this.envsList;+    }++    public setAllEnvs(envs: PythonEnvInfo[]): void {+        this.envsList = cloneDeep(envs);+    }++    public getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined {+        // Retrieve all keys with non-undefined values.+        type EnvParamKeys = keyof typeof env;+        const keys = (Object.keys(env) as unknown as EnvParamKeys[]).filter((key) => env[key] !== undefined);++        // Return the first object where the values match env's.+        return this.envsList?.find((info) => {+            // Check if there is any mismatch between the values of the in-memory info and env.+            const mismatch = keys.some((key) => info[key] !== env[key]);++            return !mismatch;+        });+    }

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;

 export function arePathsSame(path1: string, path2: string): boolean {     }     return path1 === path2; }++function getPersistentStateFactory(): IPersistentStateFactory {+    return internalServiceContainer.get<IPersistentStateFactory>(IPersistentStateFactory);+}++export function createGlobalPersistentStore<T>(key: string): IPersistentState<T> {

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');+        this.envsList = this.persistentStorage?.value;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {+        this.persistentStorage = createGlobalPersistentStore<PythonEnvInfo[]>('PYTHON_ENV_INFO_CACHE');

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;++    constructor(private readonly isComplete: CompleteEnvInfoFunction) {}++    public initialize(): void {

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { cloneDeep } from 'lodash';+import { IPersistentState } from '../../common/types';+import { createGlobalPersistentStore } from '../common/externalDependencies';+import { PythonEnvInfo } from './info';++/**+ * Represents the environment info cache to be used by the cache locator.+ */+export interface IEnvsCache {+    /**+     * Initialization logic to be done outside of the constructor, for example reading from persistent storage.+     */+    initialize(): void;++    /**+     * Return all environment info currently in memory for this session.+     *+     * @return An array of cached environment info, or `undefined` if there are none.+     */+    getAllEnvs(): PythonEnvInfo[] | undefined;++    /**+     * Replace all environment info currently in memory for this session.+     *+     * @param envs The array of environment info to store in the in-memory cache.+     */+    setAllEnvs(envs: PythonEnvInfo[]): void;++    /**+     * Return a specific environmnent info object.+     *+     * @param env The environment info data that will be used to look for an environment info object in the cache.+     * This object may contain incomplete environment info.+     * @return The environment info object that matches all non-undefined keys from the `env` param,+     *  `undefined` otherwise.+     */+    getEnv(env: Partial<PythonEnvInfo>): PythonEnvInfo | undefined;++    /**+     * Writes the content of the in-memory cache to persistent storage.+     */+    flush(): Promise<void>;+}++export type CompleteEnvInfoFunction = (envInfo: PythonEnvInfo) => boolean;++export class PythonEnvInfoCache implements IEnvsCache {+    private envsList: PythonEnvInfo[] | undefined;++    private persistentStorage: IPersistentState<PythonEnvInfo[]> | undefined;

 export class PythonEnvironments implements ILocator {  */ export function createAPI(): [PythonEnvironments, () => void] {     const [locators, activateLocators] = initLocators();+    // Update this to pass in an actual function that checks for env info completeness.+    const envsCache = new PythonEnvInfoCache(() => true);