@datagrok/bio 2.23.2 → 2.25.0

package/src/utils/monomer-lib/lib-manager.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-len */
 /* Do not change these import lines to match external modules in webpack configuration */
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
@@ -5,22 +6,20 @@ import * as DG from 'datagrok-api/dg';
 
 import {delay} from '@datagrok-libraries/utils/src/test';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
-import {IMonomerLib, IMonomerSet} from '@datagrok-libraries/bio/src/types';
+import {DEFAULT_FILES_LIB_PROVIDER_NAME, findProviderWithLibraryName, IMonomerLib, IMonomerSet} from '@datagrok-libraries/bio/src/types/monomer-library';
 import {
   getUserLibSettings, setUserLibSettings,
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
-import {
-  IMonomerLibFileEventManager, IMonomerLibHelper,
-} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
 import {MonomerLib} from './monomer-lib';
-import {MonomerSet} from './monomer-set';
-import {MonomerLibFileManager} from './library-file-manager/file-manager';
-import {MonomerLibFileEventManager} from './library-file-manager/event-manager';
-import {LIB_PATH, LIB_SETTINGS_FOR_TESTS, SETS_PATH} from './consts';
+import {MonomerSet} from '@datagrok-libraries/bio/src/types/monomer-library';
+import {LIB_SETTINGS_FOR_TESTS} from './consts';
 
 import {_package} from '../../package';
+import {IMonomerLibHelper, IMonomerLibProvider} from '@datagrok-libraries/bio/src/types/monomer-library';
+import {merge, Observable, Subject} from 'rxjs';
+import {MonomerLibFromFilesProvider} from './library-file-manager/monomers-lib-provider';
 
 type MonomerLibWindowType = Window & { $monomerLibHelperPromise?: Promise<MonomerLibManager> };
 declare const window: MonomerLibWindowType;
@@ -32,16 +31,63 @@ export class MonomerLibManager implements IMonomerLibHelper {
   private readonly _monomerSets = new MonomerSet('MAIN', []);
   private _initialLoadCompleted: boolean = false;
   public get initialLoadCompleted(): boolean { return this._initialLoadCompleted; }
-  private _eventManager: MonomerLibFileEventManager;
 
-  public get eventManager(): IMonomerLibFileEventManager { return this._eventManager; }
+  private _providersDataChanged = new Subject<void>();
+  public get providersDataChanged(): Observable<void> {
+    return this._providersDataChanged;
+  }
+
+  private _fileUploadRequested = new Subject<void>();
+  public get fileUploadRequested(): Observable<void> {
+    return this._fileUploadRequested;
+  }
+  public requestFileUpload(): void {
+    this._fileUploadRequested.next();
+  }
+
+  private _selectionChanged = new Subject<void>();
+  public get librarySelectionChanged(): Observable<void> {
+    return this._selectionChanged;
+  }
+  public notifyLibrarySelectionChanged(): void {
+    this._selectionChanged.next();
+  }
+
+  async getAvaliableLibraryNames(refresh: boolean = false): Promise<string[]> {
+    const providers = await this.getProviders();
+    const libNames: string[] = [];
+    for (const provider of providers) {
+      if (refresh)
+        await provider.refreshLists();
+      const names = await provider.listLibraries();
+      libNames.push(...names);
+    }
+    return libNames;
+  }
+
+  async refreshValidLibraryLists(): Promise<void> {
+    const providers = await this.getProviders();
+    await Promise.all(providers.map(async (provider) => provider.refreshLists()));
+  }
+
+  async getAvailableLibrariesPerProvider(): Promise<Map<string, string[]>> {
+    const providers = await this.getProviders();
+    const libNamesMap: Map<string, string[]> = new Map();
+    for (const provider of providers) {
+      const names = await provider.listLibraries();
+      libNamesMap.set(provider.name, names);
+    }
+    return libNamesMap;
+  }
+
 
   public async awaitLoaded(timeout: number = Infinity): Promise<void> {
     timeout = timeout === Infinity ? 1 * 60000 : timeout; // Limit the max lib loaded timeout
     return await Promise.race([
       (async () => {
-        const fileManager = await this.getFileManager();
-        await fileManager.filesPromise;
+        const providers = await this.getProviders();
+        await Promise.all(providers.map(async (provider) => provider.loadPromise));
+        await this.loadLibrariesPromise;
         return true;
       })(),
       (async () => {
@@ -54,6 +100,24 @@ export class MonomerLibManager implements IMonomerLibHelper {
     });
   }
 
+  private _monomerLibProviders: IMonomerLibProvider[] | null = null;
+  public async getProviders(): Promise<IMonomerLibProvider[]> {
+    if (this._monomerLibProviders == null) {
+      const providerFuncs = DG.Func.find({tags: ['monomer-lib-provider']});
+      this._monomerLibProviders = await Promise.all(providerFuncs.map(async (func) => {
+        return (await func.apply({})) as IMonomerLibProvider;
+      }));
+      // hard coded files provider from bio package
+      this._monomerLibProviders.push(await MonomerLibFromFilesProvider.getInstance(this, _package.logger));
+
+      // eslint-disable-next-line rxjs/no-ignored-subscription --- needed for the lifetime of app
+      DG.debounce(merge(...this._monomerLibProviders.map((p) => p.onChanged)), 200).subscribe(() => {
+        this._providersDataChanged.next();
+      });
+    }
+    return this._monomerLibProviders;
+  }
+
   /** Protect constructor to prevent multiple instantiation. */
   protected constructor(
     private readonly logger: ILogger,
@@ -101,23 +165,9 @@ export class MonomerLibManager implements IMonomerLibHelper {
     this._monomerLib.assignDuplicatePreferences(settings);
   }
 
-  /** Instance promise of {@link getFileManager} */
-  private _fileManagerPromise?: Promise<MonomerLibFileManager>;
-
-  async getFileManager(): Promise<MonomerLibFileManager> {
-    if (this._fileManagerPromise === undefined) {
-      this._fileManagerPromise = (async () => {
-        const fileManager: MonomerLibFileManager =
-          await MonomerLibFileManager.create(this, this._eventManager, this.logger);
-        await fileManager.initializedPromise;
-        return fileManager;
-      })();
-    }
-    return this._fileManagerPromise;
-  }
 
   /** Allows syncing with managing settings/loading libraries */
-  public loadLibrariesPromise: Promise<void> = Promise.resolve();
+  private loadLibrariesPromise: Promise<void> = Promise.resolve();
 
   /** Loads libraries based on settings in user storage {@link LIB_STORAGE_NAME}
    * @param {boolean} reload Clean {@link monomerLib} before load libraries [false]
@@ -130,36 +180,44 @@ export class MonomerLibManager implements IMonomerLibHelper {
 
       const pi = DG.TaskBarProgressIndicator.create('Loading monomers ...');
       try {
-        const [[libFileNameList,], settings]: [[string[],], UserLibSettings] =
-          await Promise.all([
-            await this.getFileManager().then((fileManager) => {
-              return [fileManager.getValidLibraryPaths(),];
-            }),
-            getUserLibSettings(),
-          ]);
-
-        const filteredLibFnList = libFileNameList.filter((libFileName) => {
-          const isFileIncluded = !settings.exclude.includes(libFileName);
-          const isExplicit = settings.explicit.length === 0 || settings.explicit.includes(libFileName);
-
-          return isFileIncluded && isExplicit;
+        // const [[libFileNameList,], settings]: [[string[],], UserLibSettings] =
+        //   await Promise.all([
+        //     await this.getFileManager().then((fileManager) => {
+        //       return [fileManager.getValidLibraryPaths(),];
+        //     }),
+        //     getUserLibSettings(),
+        //   ]);
+        const settings: UserLibSettings = await getUserLibSettings();
+        const providers = await this.getProviders();
+        const libNames = await Promise.all(providers.map(async (provider) => provider.listLibraries()));
+        libNames.forEach((names, i) => {
+          libNames[i] = names.filter((name) => {
+            const isFileIncluded = !settings.exclude.includes(name);
+            const isExplicit = (settings.explicit?.length ?? 0) === 0 || settings.explicit.includes(name);
+            return isFileIncluded && isExplicit;
+          });
         });
 
         let completedFileCount: number = 0;
-        const allCount: number = filteredLibFnList.length;
-        const [libs,]: [IMonomerLib[],] = await Promise.all([
-          Promise.all(filteredLibFnList.map((libFileName) => {
-            return this.readLibrary(LIB_PATH, libFileName)
-              .catch((err: any) => {
-                const errMsg: string = `Loading monomers from '${libFileName}' error: ` +
-                  `${err instanceof Error ? err.message : err.toString()}`;
-                return new MonomerLib({}, libFileName, errMsg);
-              })
-              .finally(() => {
-                pi.update(Math.round(100 * (++completedFileCount) / allCount),
-                  `Loading monomers ${completedFileCount}/${allCount}`);
-              });
-          })),]);
+        const libs: IMonomerLib[] = [];
+        for (let i = 0; i < providers.length; i++) {
+          const provider = providers[i];
+          const names = libNames[i];
+          try {
+            const libDatas = await provider.loadLibraries(names);
+            for (let j = 0; j < libDatas.length; j++)
+              libs.push(new MonomerLib(libDatas[j], names[j]));
+          } catch (err: any) {
+            grok.shell.warning(`Loading monomer libraries from provider '${provider.name}' failed: ` +
+            ``);
+            this.logger.error(`Loading monomer libraries from provider '${provider.name}' failed: ` +
+            `${err instanceof Error ? err.message : err.toString()}`);
+          }
+          pi.update(Math.round(100 * (++completedFileCount) / providers.length),
+            `Loading monomers ${completedFileCount}/${providers.length}`);
+        }
+
+
         this._monomerLib.updateLibs(libs, reload);
         this._initialLoadCompleted = true;
       } catch (err: any) {
@@ -189,7 +247,7 @@ export class MonomerLibManager implements IMonomerLibHelper {
 
   private loadSetsPromise: Promise<void> = Promise.resolve();
 
-  async loadMonomerSets(reload: boolean = false): Promise<void> {
+  async loadMonomerSets(_reload: boolean = false): Promise<void> {
     const logPrefix = `${this.toLog()}.loadMonomerSets()`;
 
     this.logger.debug(`${logPrefix}, start`);
@@ -197,31 +255,53 @@ export class MonomerLibManager implements IMonomerLibHelper {
       this.logger.debug(`${logPrefix}, IN`);
       const pi = DG.TaskBarProgressIndicator.create(`Loading monomer sets ...`);
       try {
-        const [[setFileNameList,]]: [[string[],],] = await Promise.all([
-          await this.getFileManager().then((fileManager) => {
-            return [fileManager.getValidSetPaths(),];
-          })
-        ]);
+        // const [[setFileNameList,]]: [[string[],],] = await Promise.all([
+        //   await this.getFileManager().then((fileManager) => {
+        //     return [fileManager.getValidSetPaths(),];
+        //   })
+        // ]);
+
+        // // TODO: Filter for settings
+        // const filteredSetFnList = setFileNameList.filter((setFileName) => true);
+
+        // let completedFileCount: number = 0;
+        // const allCount: number = filteredSetFnList.length;
+        // const [sets,]: [IMonomerSet[],] = await Promise.all([
+        //   Promise.all(filteredSetFnList.map((setFileName) => {
+        //     // TODO: handle whether files are in place
+        //     return this.readSet(SETS_PATH, setFileName)
+        //       .catch((err: any) => {
+        //         const errMsg: string = `Loading monomer sets from '${setFileName}' error: ` +
+        //           `${err instanceof Error ? err.message : err.toString()}`;
+        //         return new MonomerSet('Broken monomer set', [], setFileName, errMsg);
+        //       })
+        //       .finally(() => {
+        //         pi.update(Math.round(100 * (++completedFileCount) / allCount),
+        //           `Loading monomers ${completedFileCount}/${allCount}`);
+        //       });
+        //   })),]);
+        const providers = await this.getProviders();
+        const setNames = await Promise.all(providers.map(async (provider) => provider.listSets()));
+        const sets: IMonomerSet[] = [];
+        let completedFileCount: number = 0;
+        for (let i = 0; i < providers.length; i++) {
+          const provider = providers[i];
+          const names = setNames[i];
+          try {
+            const setDatas = await provider.loadSets(names);
+            for (let j = 0; j < setDatas.length; j++)
+              sets.push(setDatas[j]);
+          } catch (err: any) {
+            grok.shell.warning(`Loading monomer sets from provider '${provider.name}' failed: ` +
+            ``);
+            this.logger.error(`Loading monomer sets from provider '${provider.name}' failed: ` +
+            `${err instanceof Error ? err.message : err.toString()}`);
+          }
+          pi.update(Math.round(100 * (++completedFileCount) / providers.length),
+            `Loading monomer sets ${completedFileCount}/${providers.length}`);
+        }
 
-        // TODO: Filter for settings
-        const filteredSetFnList = setFileNameList.filter((setFileName) => true);
 
-        let completedFileCount: number = 0;
-        const allCount: number = filteredSetFnList.length;
-        const [sets,]: [IMonomerSet[],] = await Promise.all([
-          Promise.all(filteredSetFnList.map((setFileName) => {
-            // TODO: handle whether files are in place
-            return this.readSet(SETS_PATH, setFileName)
-              .catch((err: any) => {
-                const errMsg: string = `Loading monomer sets from '${setFileName}' error: ` +
-                  `${err instanceof Error ? err.message : err.toString()}`;
-                return new MonomerSet('Broken monomer set', [], setFileName, errMsg);
-              })
-              .finally(() => {
-                pi.update(Math.round(100 * (++completedFileCount) / allCount),
-                  `Loading monomers ${completedFileCount}/${allCount}`);
-              });
-          })),]);
         this._monomerSets.updateSets(sets);
       } catch (err: any) {
         const errMsg: string = 'Loading monomer sets error: ' +
@@ -239,47 +319,95 @@ export class MonomerLibManager implements IMonomerLibHelper {
     return this.loadSetsPromise;
   }
 
-  /** Reads library from file shares, handles .json and .sdf
-   * @param {string} path Path to library file
-   * @param {string} fileName Name of library file
-   * @return {Promise<IMonomerLib>} Promise of IMonomerLib
-   */
-  async readLibrary(path: string, fileName: string): Promise<IMonomerLib> {
-    const fileManager = await this.getFileManager();
-    const lib: IMonomerLib = await fileManager.loadLibraryFromFile(path, fileName);
-    return lib;
-  }
+  // /** Reads library from file shares, handles .json and .sdf
+  //  * @param {string} path Path to library file
+  //  * @param {string} fileName Name of library file
+  //  * @return {Promise<IMonomerLib>} Promise of IMonomerLib
+  //  */
+  // async readLibrary(path: string, fileName: string): Promise<IMonomerLib> {
+  //   const fileManager = await this.getFileManager();
+  //   const lib: IMonomerLib = await fileManager.loadLibraryFromFile(path, fileName);
+  //   return lib;
+  // }
+
+  // async readSet(path: string, fileName: string): Promise<IMonomerSet> {
+  //   const fileManager = await this.getFileManager();
+  //   const set: IMonomerSet = await fileManager.loadSetFromFile(this._monomerLib, path, fileName);
+  //   return set;
+  // }
+  // -- Settings --
 
-  async readSet(path: string, fileName: string): Promise<IMonomerSet> {
-    const fileManager = await this.getFileManager();
-    const set: IMonomerSet = await fileManager.loadSetFromFile(this._monomerLib, path, fileName);
-    return set;
+  /** Changes userLibSettings set only HELMCoreLibrary.json, polytool-lib.json */
+  async loadMonomerLibForTests(): Promise<void> {
+    await setUserLibSettings(LIB_SETTINGS_FOR_TESTS);
+    await this.awaitLoaded(10000);
+    await this.loadMonomerLib(true); // load default libraries
   }
 
-  /** Reset user settings to the specified library. WARNING: clears user * settings */
-  public async selectSpecifiedLibraries(libFileNameList: string[]): Promise<void> {
-    const invalidNames = await this.getInvalidFileNames(libFileNameList);
-    if (invalidNames.length > 0)
-      throw new Error(`Cannot select libraries ${invalidNames}: no such library in the list`);
-    const settings = await getUserLibSettings();
-    settings.exclude = ((await this.getFileManager()).getValidLibraryPaths())
-      .filter((fileName) => !libFileNameList.includes(fileName));
-    await setUserLibSettings(settings);
+  async readSingleLibrary(providerName: string, libraryName: string): Promise<IMonomerLib | null> {
+    const providers = await this.getProviders();
+    const provider = providers.find((p) => p.name === providerName);
+    if (!provider) {
+      this.logger.error(`Provider '${providerName}' not found.`);
+      return null;
+    }
+    try {
+      const libDatas = await provider.loadLibraries([libraryName]);
+      if (libDatas.length === 0) {
+        this.logger.error(`Library '${libraryName}' not found in provider '${providerName}'.`);
+        return null;
+      }
+      return new MonomerLib(libDatas[0], libraryName);
+    } catch (err: any) {
+      this.logger.error(`Loading monomer library '${libraryName}' from provider '${provider.name}' failed: ` +
+      `${err instanceof Error ? err.message : err.toString()}`);
+      return null;
+    }
   }
 
-  private async getInvalidFileNames(libFileNameList: string[]): Promise<string[]> {
-    const availableFileNames = (await this.getFileManager()).getValidLibraryPaths();
-    const invalidNames = libFileNameList.filter((fileName) => !availableFileNames.includes(fileName));
-    return invalidNames;
+
+  async readLibraryFromFilePath(filePath: string): Promise<IMonomerLib> {
+    const provider: MonomerLibFromFilesProvider = (await this.getProviders()).find((p) => p.name === DEFAULT_FILES_LIB_PROVIDER_NAME) as MonomerLibFromFilesProvider;
+    if (!provider) {
+      // Just in case, but this should never happen
+      throw new Error(`Provider '${DEFAULT_FILES_LIB_PROVIDER_NAME}' not found.`);
+    }
+
+    const res = await provider.getSingleLibraryWithFullPath(filePath);
+    if (!res)
+      throw new Error(`Library at path '${filePath}' not found.`);
+    return new MonomerLib(res, filePath);
   }
 
-  // -- Settings --
+  async readSingleLibraryByName(libraryName: string): Promise<IMonomerLib | null> {
+    const providers = await this.getProviders();
+    const provider = await findProviderWithLibraryName(providers, libraryName);
+    if (!provider) {
+      this.logger.error(`No provider found for library '${libraryName}'.`);
+      return null;
+    }
+    return this.readSingleLibrary(provider.name, libraryName);
+  }
 
-  /** Changes userLibSettings set only HELMCoreLibrary.json, polytool-lib.json */
-  async loadMonomerLibForTests(): Promise<void> {
-    await setUserLibSettings(LIB_SETTINGS_FOR_TESTS);
-    await this.awaitLoaded(10000);
-    await this.loadMonomerLib(true); // load default libraries
+  async readSingleSet(providerName: string, setName: string): Promise<IMonomerSet | null> {
+    const providers = await this.getProviders();
+    const provider = providers.find((p) => p.name === providerName);
+    if (!provider) {
+      this.logger.error(`Provider '${providerName}' not found.`);
+      return null;
+    }
+    try {
+      const setDatas = await provider.loadSets([setName]);
+      if (setDatas.length === 0) {
+        this.logger.error(`Set '${setName}' not found in provider '${providerName}'.`);
+        return null;
+      }
+      return setDatas[0];
+    } catch (err: any) {
+      this.logger.error(`Loading monomer set '${setName}' from provider '${provider.name}' failed: ` +
+      `${err instanceof Error ? err.message : err.toString()}`);
+      return null;
+    }
   }
 
   // -- Instance singleton --
@@ -288,7 +416,6 @@ export class MonomerLibManager implements IMonomerLibHelper {
     if (res == undefined) {
       res = window.$monomerLibHelperPromise = (async () => {
         const instance = new MonomerLibManager(_package.logger);
-        instance._eventManager = MonomerLibFileEventManager.getInstance();
         return instance;
       })();
     }

package/src/utils/monomer-lib/library-file-manager/file-validator.ts

@@ -22,7 +22,7 @@ export class MonomerLibFileValidator {
 
   validateFile(fileContent: string, fileName: string): boolean {
     const jsonContent = this.parseJson(fileContent, fileName);
-    if (jsonContent === null)
+    if (jsonContent == null)
       return false;
 
     if (!Array.isArray(jsonContent)) {