Class OldPythonApiProvider

src/platform/api/pythonApi.ts:106–225

/* eslint-disable max-classes-per-file */
@injectable()
export class OldPythonApiProvider implements IPythonApiProvider {
    private readonly api = createDeferred<PythonApi>();
    private readonly didActivatePython = new EventEmitter<void>();
    private readonly _pythonExtensionHooked = createDeferred<void>();
    public get onDidActivatePythonExtension() {
        return this.didActivatePython.event;
    }

    // This promise will resolve when the python extension is hooked
    public get pythonExtensionHooked(): Promise<void> {
        return this._pythonExtensionHooked.promise;
    }
    public get pythonExtensionVersion(): SemVer | undefined {
        return this._pythonExtensionVersion;
    }

    private initialized?: boolean;
    private hooksRegistered?: boolean;
    private _pythonExtensionVersion?: SemVer | undefined;

    constructor(
        @inject(IDisposableRegistry) private readonly disposables: IDisposableRegistry,
        @inject(IPythonExtensionChecker) private extensionChecker: IPythonExtensionChecker
    ) {
        const previouslyInstalled = this.extensionChecker.isPythonExtensionInstalled;
        if (!previouslyInstalled) {
            extensions.onDidChange(
                async () => {
                    if (this.extensionChecker.isPythonExtensionInstalled) {
                        await this.registerHooks();
                    }
                },
                this,
                this.disposables
            );
        }
        this.disposables.push(this.didActivatePython);
    }

    public getApi(): Promise<PythonApi> {
        this.init().catch(noop);
        return this.api.promise;
    }
    public async getNewApi(): Promise<PythonExtensionApi | undefined> {
        await this.init();
        const extension = extensions.getExtension<PythonExtensionApi>(PythonExtension);
        if (extension?.packageJSON?.version) {
            this._pythonExtensionVersion = new SemVer(extension?.packageJSON?.version);
        }
        if (extension?.exports) {
            setPythonApi(extension.exports);
            extension.exports.environments.known.forEach((e) => {
                trackInterpreterDiscovery(e);
            });
        }
        return extension?.exports;
    }