@datagrok/bio 2.11.30 → 2.11.33

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

@@ -0,0 +1,187 @@
+/* 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';
+import * as DG from 'datagrok-api/dg';
+
+import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types/index';
+import {LIB_PATH} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {MonomerLib} from '../monomer-lib';
+import {
+  HELM_REQUIRED_FIELD as REQ,
+} from '@datagrok-libraries/bio/src/utils/const';
+import {JSONSchemaType} from 'ajv';
+import {HELM_JSON_SCHEMA_PATH} from './consts';
+import {MonomerLibFileEventManager} from './event-manager';
+
+import {MonomerLibFileValidator} from './file-validator';
+import {MonomerLibManager} from '../lib-manager';
+
+/** Singleton for adding, validation and reading of monomer library files.
+ * All files **must** be aligned to the HELM standard before adding. */
+export class MonomerLibFileManager {
+  private constructor(
+    private libraryFileValidator: MonomerLibFileValidator,
+    private libraryEventManager: MonomerLibFileEventManager,
+  ) {
+    this.libraryEventManager.updateValidLibraryFileListRequested$.subscribe(async () => {
+      await this.updateValidLibraryList();
+    });
+  }
+
+  private static instance: MonomerLibFileManager | undefined;
+
+  static async getInstance(
+    libraryEventManager: MonomerLibFileEventManager,
+  ): Promise<MonomerLibFileManager> {
+    if (MonomerLibFileManager.instance === undefined) {
+      const helmSchemaRaw = await grok.dapi.files.readAsText(HELM_JSON_SCHEMA_PATH);
+      const helmSchema = JSON.parse(helmSchemaRaw) as JSONSchemaType<any>;
+
+      const fileValidator = new MonomerLibFileValidator(helmSchema);
+      MonomerLibFileManager.instance = new MonomerLibFileManager(fileValidator, libraryEventManager);
+    }
+
+    return MonomerLibFileManager.instance;
+  }
+
+  /** Add standard .json monomer library  */
+  async addLibraryFile(fileContent: string, fileName: string): Promise<void> {
+    try {
+      if (await this.libraryFileExists(fileName)) {
+        grok.shell.error(`File ${fileName} already exists`);
+        return;
+      }
+
+      await this.validateAgainstHELM(fileContent, fileName);
+      await grok.dapi.files.writeAsText(LIB_PATH + `${fileName}`, fileContent);
+      await this.updateValidLibraryList();
+      const fileExists = await grok.dapi.files.exists(LIB_PATH + `${fileName}`);
+      if (!fileExists)
+        grok.shell.error(`Failed to add ${fileName} library`);
+      else
+        grok.shell.info(`Added ${fileName} HELM library`);
+    } catch (e) {
+      console.error(e);
+      grok.shell.error(`Failed to add ${fileName} library`);
+    }
+  }
+
+  async deleteLibraryFile(fileName: string): Promise<void> {
+    try {
+      await grok.dapi.files.delete(LIB_PATH + `${fileName}`);
+      await this.updateValidLibraryList();
+      grok.shell.info(`Deleted ${fileName} library`);
+    } catch (e) {
+      console.error(e);
+      const fileExists = await grok.dapi.files.exists(LIB_PATH + `${fileName}`);
+      if (fileExists)
+        grok.shell.error(`Failed to delete ${fileName} library`);
+      else
+        grok.shell.warning(`File ${fileName} already deleted, refresh the list`);
+    }
+  }
+
+  async loadLibraryFromFile(path: string, fileName: string): Promise<IMonomerLib> {
+    let rawLibData: any[] = [];
+    const fileSource = new DG.FileSource(path);
+    const file = await fileSource.readAsText(fileName);
+    rawLibData = JSON.parse(file);
+    const monomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer } } = {};
+    const polymerTypes: string[] = [];
+    rawLibData.forEach((monomer) => {
+      if (!polymerTypes.includes(monomer[REQ.POLYMER_TYPE])) {
+        monomers[monomer[REQ.POLYMER_TYPE]] = {};
+        polymerTypes.push(monomer[REQ.POLYMER_TYPE]);
+      }
+      monomers[monomer[REQ.POLYMER_TYPE]][monomer[REQ.SYMBOL]] = monomer as Monomer;
+    });
+
+    return new MonomerLib(monomers);
+  }
+
+  getValidLibraryPaths(): string[] {
+    return this.libraryEventManager.getValidFilesPathList();
+  }
+
+  private async libraryFileExists(fileName: string): Promise<boolean> {
+    return await grok.dapi.files.exists(LIB_PATH + `${fileName}`);
+  }
+
+  private async updateValidLibraryList(): Promise<void> {
+    const invalidFiles = [] as string[];
+    // console.log(`files before validation:`, this.libraryEventManager.getValidFilesPathList());
+    const filePaths = await this.getFilePathsAtDefaultLocation();
+
+    if (!this.fileListHasChanged(filePaths))
+      return;
+
+    for (const path of filePaths) {
+      if (!path.endsWith('.json')) {
+        invalidFiles.push(path);
+        continue;
+      }
+
+      const fileContent = await grok.dapi.files.readAsText(LIB_PATH + `${path}`);
+      if (!this.isValidHELMLibrary(fileContent, path))
+        invalidFiles.push(path);
+    }
+
+    const validLibraryPaths = filePaths.filter((path) => !invalidFiles.includes(path));
+
+    if (this.fileListHasChanged(validLibraryPaths)) {
+      this.libraryEventManager.changeValidFilesPathList(validLibraryPaths);
+      MonomerLibManager.instance.loadLibraries(true);
+    }
+    // console.log(`files after validation:`, this.libraryEventManager.getValidFilesPathList());
+
+    if (validLibraryPaths.some((el) => !el.endsWith('.json')))
+      console.warn(`Wrong validation: ${validLibraryPaths}`);
+
+    if (invalidFiles.length > 0) {
+      const message = `Invalid monomer library files in ${LIB_PATH}` +
+      `, consider fixing or removing them: ${invalidFiles.join(', ')}`;
+
+      console.warn(message);
+      grok.shell.warning(message);
+    }
+  }
+
+  private fileListHasChanged(newList: string[]): boolean {
+    const currentList = this.libraryEventManager.getValidFilesPathList();
+    return newList.length !== currentList.length || newList.some((el, i) => el !== currentList[i]);
+  }
+
+  private async validateAgainstHELM(fileContent: string, fileName: string): Promise<void> {
+    const isValid = this.isValidHELMLibrary(fileContent, fileName);
+    if (!isValid)
+      throw new Error(`File ${fileName} does not satisfy HELM standard`);
+  }
+
+  private isValidHELMLibrary(fileContent: string, fileName: string): boolean {
+    return this.libraryFileValidator.validateFile(fileContent, fileName);
+  }
+
+  /** Get relative paths for files in LIB_PATH  */
+  private async getFilePathsAtDefaultLocation(): Promise<string[]> {
+    const list = await grok.dapi.files.list(LIB_PATH);
+    const paths = list.map((fileInfo) => {
+      return fileInfo.fullPath;
+    });
+
+    // console.log(`retreived paths:`, paths);
+
+    // WARNING: an extra sanity check,
+    // caused by unexpected behavior of grok.dapi.files.list() when it returns non-existent paths
+    const existingPaths = [] as string[];
+    for (const path of paths) {
+      const exists = await grok.dapi.files.exists(path);
+      if (exists)
+        existingPaths.push(path);
+    }
+
+    return existingPaths.map((path) => {
+      // Get relative path (to LIB_PATH)
+      return path.substring(LIB_PATH.length);
+    });
+  }
+}

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

@@ -0,0 +1,56 @@
+import {JSONSchemaType, ValidateFunction} from 'ajv';
+import Ajv2020 from 'ajv/dist/2020';
+import addErrors from 'ajv-errors';
+
+export class MonomerLibFileValidator {
+  private validateMonomerSchema: ValidateFunction<any>;
+
+  constructor(private helmMonomerSchema: JSONSchemaType<any>) {
+    const ajv = new Ajv2020({allErrors: true, strictTuples: false});
+    addErrors(ajv);
+    this.validateMonomerSchema = ajv.compile(this.helmMonomerSchema);
+  }
+
+  validateFile(fileContent: string, fileName: string): boolean {
+    const jsonContent = this.parseJson(fileContent);
+    if (jsonContent === null)
+      return false;
+
+    if (!Array.isArray(jsonContent)) {
+      console.warn(
+        'Bio: Monomer Library File Validator: Invalid JSON format: The file must contain an array of monomers.'
+      );
+      return false;
+    }
+
+    return this.validateJsonContent(jsonContent, fileName);
+  }
+
+  private parseJson(fileContent: string): any[] | null {
+    try {
+      return JSON.parse(fileContent);
+    } catch (e) {
+      console.error('Bio: Monomer Library File Validator: Invalid JSON format:', e);
+      return null;
+    }
+  }
+
+  private validateJsonContent(jsonContent: any[], fileName: string): boolean {
+    let isValid = true;
+    for (const monomer of jsonContent) {
+      isValid = this.validateMonomerSchema(monomer);
+      if (!isValid) {
+        console.warn(
+          `Bio: Monomer Library File Validator:\nfile${fileName}\n monomer violating JSON schema:`,
+          monomer,
+          '\nError reason: ',
+          this.validateMonomerSchema.errors,
+          `\nThere may be other errors in ${fileName} since the validation is stopped after the first error.`,
+          ' Please, verify that the monomer library file satisfies the JSON schema'
+        );
+        break;
+      }
+    }
+    return isValid;
+  }
+}

package/src/utils/monomer-lib/library-file-manager/style.css

@@ -0,0 +1,8 @@
+.monomer-lib-controls-form {
+  margin-left: auto;
+  margin-right: auto;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  width: 100%;
+}

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

@@ -0,0 +1,224 @@
+/* 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';
+import * as DG from 'datagrok-api/dg';
+
+import $ from 'cash-dom';
+import * as rxjs from 'rxjs';
+import './style.css';
+
+import {
+  getUserLibSettings, setUserLibSettings
+} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
+import {MonomerLibManager} from '../lib-manager';
+
+import {MonomerLibFileManager} from './file-manager';
+import {MonomerLibFileEventManager} from './event-manager';
+
+export async function showManageLibrariesDialog(): Promise<void> {
+  await DialogWrapper.showDialog();
+}
+
+export async function getMonomerLibraryManagerLink(): Promise<DG.Widget> {
+  const link = ui.label('Manage monomer libraries');
+  $(link).addClass('d4-link-action');
+  link.onclick = async () => await showManageLibrariesDialog();
+  return new DG.Widget(
+    link
+  );
+}
+
+class MonomerLibraryManagerWidget {
+  private constructor(
+    private eventManager: MonomerLibFileEventManager
+  ) { }
+
+  private static _instance: MonomerLibraryManagerWidget;
+
+  static async getContent(eventManager: MonomerLibFileEventManager): Promise<DG.Widget> {
+    if (!MonomerLibraryManagerWidget._instance)
+      MonomerLibraryManagerWidget._instance = new MonomerLibraryManagerWidget(eventManager);
+
+    if (!MonomerLibraryManagerWidget._instance.widget)
+      MonomerLibraryManagerWidget._instance.widget = await MonomerLibraryManagerWidget._instance.createWidget();
+
+    return MonomerLibraryManagerWidget._instance.widget;
+  }
+
+  private monomerLibFileManager: MonomerLibFileManager;
+  private widget: DG.Widget | undefined;
+
+  private async createWidget() {
+    this.monomerLibFileManager = await MonomerLibFileManager.getInstance(this.eventManager);
+    const content = await this.getWidgetContent();
+    this.eventManager.addLibraryFileRequested$.subscribe(
+      async () => await this.promptToAddLibraryFiles()
+    );
+    return new DG.Widget(content);
+  }
+
+  private async getWidgetContent(): Promise<HTMLElement> {
+    this.monomerLibFileManager = await MonomerLibFileManager.getInstance(this.eventManager);
+    const libControlsForm = await LibraryControlsManager.createControlsForm(this.eventManager);
+    $(libControlsForm).addClass('monomer-lib-controls-form');
+    const widgetContent = ui.divV([libControlsForm]);
+    return widgetContent;
+  }
+
+  private async promptToAddLibraryFiles(): Promise<void> {
+    DG.Utils.openFile({
+      accept: '.json',
+      open: async (selectedFile) => {
+        const content = await selectedFile.text();
+        const name = selectedFile.name;
+        const progressIndicator = DG.TaskBarProgressIndicator.create(`Adding ${name} as a monomer library`);
+        try {
+          await this.monomerLibFileManager.addLibraryFile(content, name);
+          // this.eventManager.updateLibrarySelectionStatus(name, true);
+        } catch (e) {
+          grok.shell.error(`File ${name} is not a valid monomer library, verify it is aligned to HELM JSON schema.`);
+        } finally {
+          progressIndicator.close();
+        }
+      },
+    });
+  }
+}
+
+class LibraryControlsManager {
+  private constructor(private eventManager: MonomerLibFileEventManager) {
+    this.eventManager.updateUIControlsRequested$.subscribe(
+      async () => await this.updateControlsForm()
+    );
+    this.eventManager.librarySelectionRequested$.subscribe(
+      async ([fileName, isSelected]) => await this.updateLibrarySelectionStatus(isSelected, fileName)
+    );
+  }
+  private monomerLibFileManager: MonomerLibFileManager;
+  private userLibSettings: UserLibSettings;
+
+  static async createControlsForm(eventManager: MonomerLibFileEventManager): Promise<HTMLElement> {
+    const manager = new LibraryControlsManager(eventManager);
+    await manager.initialize();
+
+    return await manager._createControlsForm();
+  }
+
+  private async _createControlsForm(): Promise<HTMLElement> {
+    this.monomerLibFileManager = await MonomerLibFileManager.getInstance(this.eventManager);
+    const libraryControls = await this.createLibraryControls();
+    const inputsForm = ui.form(libraryControls);
+    $(inputsForm).addClass('monomer-lib-controls-form');
+
+    return inputsForm;
+  }
+
+  private async initialize(): Promise<void> {
+    this.userLibSettings = await getUserLibSettings();
+  };
+
+  private async updateControlsForm(): Promise<void> {
+    const updatedForm = await this._createControlsForm();
+    $('.monomer-lib-controls-form').replaceWith(updatedForm);
+  }
+
+  private async createLibraryControls(): Promise<DG.InputBase<boolean | null>[]> {
+    const fileManager = await MonomerLibFileManager.getInstance(this.eventManager);
+    const libFileNameList: string[] = fileManager.getValidLibraryPaths();
+    return libFileNameList.map((libFileName) => this.createLibInput(libFileName));
+  }
+
+  private createLibInput(libFileName: string): DG.InputBase<boolean | null> {
+    const isMonomerLibrarySelected = !this.userLibSettings.exclude.includes(libFileName);
+    const libInput = ui.boolInput(
+      libFileName,
+      isMonomerLibrarySelected,
+      (isSelected: boolean) => this.eventManager.updateLibrarySelectionStatus(libFileName, isSelected)
+    );
+    ui.tooltip.bind(libInput.root, `Include monomers from ${libFileName}`);
+    const deleteIcon = ui.iconFA('trash-alt', () => this.promptForLibraryDeletion(libFileName));
+    ui.tooltip.bind(deleteIcon, `Delete ${libFileName}`);
+    libInput.addOptions(deleteIcon);
+    return libInput;
+  }
+
+  private async updateLibrarySelectionStatus(
+    isMonomerLibrarySelected: boolean,
+    libFileName: string
+  ): Promise<void> {
+    this.updateLibrarySettings(isMonomerLibrarySelected, libFileName);
+    await setUserLibSettings(this.userLibSettings);
+    await MonomerLibManager.instance.loadLibraries(true);
+    grok.shell.info('Monomer library user settings saved');
+  }
+
+  private updateLibrarySettings(
+    isLibrarySelected: boolean | null,
+    libFileName: string,
+  ): void {
+    if (isLibrarySelected) {
+      // Remove selected library from exclusion list
+      this.userLibSettings.exclude = this.userLibSettings.exclude.filter((libName) => libName !== libFileName);
+    } else if (!this.userLibSettings.exclude.includes(libFileName)) {
+      // Add unselected library to exclusion list
+      this.userLibSettings.exclude.push(libFileName);
+    }
+  }
+
+  private promptForLibraryDeletion(fileName: string): void {
+    const dialog = ui.dialog('Warning');
+    dialog.add(ui.divText(`Delete file ${fileName}?`))
+      .onOK(async () => {
+        try {
+          const progressIndicator = DG.TaskBarProgressIndicator.create(`Deleting ${fileName} library`);
+          this.updateLibrarySelectionStatus(false, fileName);
+          await this.monomerLibFileManager.deleteLibraryFile(fileName);
+          progressIndicator.close();
+        } catch (e) {
+          console.error(e);
+          grok.shell.error(`Failed to delete ${fileName} library`);
+        }
+      })
+      .showModal(false);
+  }
+}
+
+class DialogWrapper {
+  private constructor() { }
+
+  private static _instance: DialogWrapper;
+  private dialog?: DG.Dialog;
+  private closeDialogSubject$ = new rxjs.Subject<void>();
+
+  static async showDialog(): Promise<void> {
+    if (!DialogWrapper._instance) {
+      DialogWrapper._instance = new DialogWrapper();
+      DialogWrapper._instance.closeDialogSubject$.subscribe(
+        () => { DialogWrapper._instance.dialog = undefined; }
+      );
+    }
+
+    if (!DialogWrapper._instance.dialog)
+      DialogWrapper._instance.dialog = await DialogWrapper._instance.getDialog();
+
+    DialogWrapper._instance.dialog.show();
+  }
+
+  private async getDialog(): Promise<DG.Dialog> {
+    const eventManager = MonomerLibFileEventManager.getInstance();
+    const widget = await MonomerLibraryManagerWidget.getContent(eventManager);
+    const dialog = ui.dialog('Manage monomer libraries');
+    $(dialog.root).css('width', '350px');
+    dialog.clear();
+    dialog.addButton(
+      'Add',
+      () => eventManager.addLibraryFile(),
+      undefined,
+      'Upload new HELM monomer library'
+    );
+    dialog.add(widget);
+    dialog.onClose.subscribe(() => this.closeDialogSubject$.next());
+    return dialog;
+  }
+}

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

@@ -0,0 +1,114 @@
+/* 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';
+import * as DG from 'datagrok-api/dg';
+
+import {Observable, Subject} from 'rxjs';
+
+import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types/index';
+import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
+
+import {_package} from '../../package';
+
+/** Wrapper for monomers obtained from different sources. For managing monomere
+ * libraries, use MolfileHandler class instead */
+export class MonomerLib implements IMonomerLib {
+  public readonly error: string | undefined;
+
+  private _monomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer } } = {};
+  private _onChanged = new Subject<any>();
+
+  constructor(monomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer } }, error?: string) {
+    this._monomers = monomers;
+    this.error = error;
+  }
+
+  getMonomer(polymerType: string, monomerSymbol: string): Monomer | null {
+    if (polymerType in this._monomers! && monomerSymbol in this._monomers![polymerType])
+      return this._monomers![polymerType][monomerSymbol];
+    else
+      return null;
+  }
+
+  getPolymerTypes(): string[] {
+    return Object.keys(this._monomers);
+  }
+
+  getMonomerMolsByPolymerType(polymerType: string): { [monomerSymbol: string]: string } {
+    const res: { [monomerSymbol: string]: string } = {};
+
+    Object.keys(this._monomers[polymerType] ?? {}).forEach((monomerSymbol) => {
+      res[monomerSymbol] = this._monomers[polymerType][monomerSymbol].molfile;
+    });
+
+    return res;
+  }
+
+  getMonomerSymbolsByType(polymerType: string): string[] {
+    return Object.keys(this._monomers[polymerType]);
+  }
+
+  /** Get a list of monomers with specified element attached to specified
+   * R-group
+   * WARNING: RGroup numbering starts from 1, not 0*/
+  getMonomerSymbolsByRGroup(rGroupNumber: number, polymerType: string, element?: string): string[] {
+    const monomerSymbols = this.getMonomerSymbolsByType(polymerType);
+    let monomers = monomerSymbols.map((sym) => this.getMonomer(polymerType, sym));
+    monomers = monomers.filter((el) => el !== null);
+    if (monomers.length === 0)
+      return [];
+
+    function findAllIndices<T>(arr: T[], element: T): number[] {
+      return arr.map((value, index) => (value === element ? index : -1))
+        .filter((index) => index !== -1);
+    }
+
+    monomers = monomers.filter((monomer) => {
+      if (!monomer?.rgroups)
+        return false;
+      let criterion = monomer?.rgroups.length >= rGroupNumber;
+      const molfileHandler = MolfileHandler.getInstance(monomer.molfile);
+      const rGroupIndices = findAllIndices(molfileHandler.atomTypes, 'R#');
+      criterion &&= true;
+      return criterion;
+    });
+    return monomers.map((monomer) => monomer?.symbol!);
+  }
+
+  get onChanged(): Observable<any> {
+    return this._onChanged;
+  }
+
+  private _updateInt(lib: IMonomerLib): void {
+    const typesNew = lib.getPolymerTypes();
+    const types = this.getPolymerTypes();
+
+    typesNew.forEach((type) => {
+      //could possibly rewrite -> TODO: check duplicated monomer symbol
+
+      if (!types.includes(type))
+        this._monomers![type] = {};
+
+      const monomers = lib.getMonomerSymbolsByType(type);
+      monomers.forEach((monomerSymbol) => {
+        this._monomers[type][monomerSymbol] = lib.getMonomer(type, monomerSymbol)!;
+      });
+    });
+  }
+
+  public update(lib: IMonomerLib): void {
+    this._updateInt(lib);
+    this._onChanged.next();
+  }
+
+  public updateLibs(libList: IMonomerLib[], reload: boolean = false): void {
+    if (reload) this._monomers = {};
+    for (const lib of libList) if (!lib.error) this._updateInt(lib);
+    this._onChanged.next();
+  }
+
+  public clear(): void {
+    this._monomers = {};
+    this._onChanged.next();
+  }
+}

package/src/utils/poly-tool/const.ts

@@ -1,3 +1,5 @@
+import {HELM_REQUIRED_FIELD} from '@datagrok-libraries/bio/src/utils/const';
+
 export const enum HELM_WRAPPER {
   LEFT = 'PEPTIDE1{',
   RIGHT = '}$$$$',
@@ -14,3 +16,29 @@ export const enum CYCLIZATION_TYPE {
   R3 = 'R3-R3',
 }
 
+export const helmFieldsToPolyToolInputFields = {
+  [HELM_REQUIRED_FIELD.SYMBOL]: 'Short Name',
+  [HELM_REQUIRED_FIELD.NAME]: 'Medium Name',
+  [HELM_REQUIRED_FIELD.SMILES]: 'SMILES',
+};
+
+export const R_GROUP_BLOCK_DUMMY = [
+  {
+    'capGroupSMILES': '[*:1][H]',
+    'alternateId': 'R1-H',
+    'capGroupName': 'H',
+    'label': 'R1'
+  },
+  {
+    'capGroupSMILES': 'O[*:2]',
+    'alternateId': 'R2-OH',
+    'capGroupName': 'OH',
+    'label': 'R2'
+  },
+  {
+    'capGroupSMILES': '[*:3][H]',
+    'alternateId': 'R3-H',
+    'capGroupName': 'H',
+    'label': 'R3'
+  }
+];