@datagrok/bio 2.12.17 → 2.12.18

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

@@ -1,10 +1,17 @@
 /* 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 wu from 'wu';
 import {Observable, Subject} from 'rxjs';
 
-import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types/index';
+import {
+  IMonomerLib, Monomer, MonomerLibSummaryType, MonomerType, PolymerType, RGroup
+} from '@datagrok-libraries/bio/src/types';
+import {
+  HELM_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP
+} from '@datagrok-libraries/bio/src/utils/const';
 import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
 
 import '../../../css/cell-renderer.css';
@@ -27,18 +34,57 @@ export class MonomerLib implements IMonomerLib {
     }
   }
 
-  getMonomer(polymerType: string, monomerSymbol: string): Monomer | null {
+  /** Creates missing {@link Monomer} */
+  addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
+    let mSet = this._monomers[polymerType];
+    if (!mSet)
+      mSet = this._monomers[polymerType] = {};
+    const m = mSet[monomerSymbol] = {
+      [REQ.SYMBOL]: monomerSymbol,
+      [REQ.NAME]: monomerSymbol,
+      [REQ.MOLFILE]: '',
+      [REQ.AUTHOR]: 'MISSING',
+      [REQ.ID]: -1,
+      [REQ.RGROUPS]:
+        wu.count(1).take(9).map((i) => {
+          return {
+            /* eslint-disable no-multi-spaces */
+            // Samples                        //  PEPTIDE     RNA
+            [RGP.CAP_GROUP_SMILES]: '',       // '[*:1][H]'  '[*:1][H]'
+            [RGP.ALTERNATE_ID]: '',           // 'R1-H'      'R1-H'
+            [RGP.CAP_GROUP_NAME]: '',         // 'H'         'H'
+            [RGP.LABEL]: `R${i.toString()}`,  // 'R1'        'R1'
+            /* eslint-enable no-multi-spaces */
+          } as RGroup;
+        }).toArray(),
+      [REQ.SMILES]: '',
+      [REQ.POLYMER_TYPE]: polymerType,
+      [REQ.MONOMER_TYPE]: undefined as unknown as MonomerType, // TODO: Can we get monomerType from atom of POM
+      [REQ.CREATE_DATE]: null,
+    } as Monomer;
+    return m;
+  }
+
+  getMonomer(polymerType: PolymerType, argMonomerSymbol: string): Monomer | null {
+    // Adjust RNA's 'R' for ribose to 'r' and 'P' for phosphate to 'p' for case-sensitive monomer names.
+    // There are uppercase 'R' and 'P' at RNA samples in test data 'helm2.csv' but lowercase in HELMCoreLibrary.json
+    let monomerSymbol = argMonomerSymbol;
+    if (polymerType == 'RNA' && monomerSymbol == 'R')
+      monomerSymbol = 'r';
+    if (polymerType == 'RNA' && monomerSymbol == 'P')
+      monomerSymbol = 'p';
+
     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);
+  getPolymerTypes(): PolymerType[] {
+    return Object.keys(this._monomers) as PolymerType[];
   }
 
-  getMonomerMolsByPolymerType(polymerType: string): { [monomerSymbol: string]: string } {
+  getMonomerMolsByPolymerType(polymerType: PolymerType): { [monomerSymbol: string]: string } {
     const res: { [monomerSymbol: string]: string } = {};
 
     Object.keys(this._monomers[polymerType] ?? {}).forEach((monomerSymbol) => {
@@ -48,14 +94,14 @@ export class MonomerLib implements IMonomerLib {
     return res;
   }
 
-  getMonomerSymbolsByType(polymerType: string): string[] {
+  getMonomerSymbolsByType(polymerType: PolymerType): 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[] {
+  getMonomerSymbolsByRGroup(rGroupNumber: number, polymerType: PolymerType, element?: string): string[] {
     const monomerSymbols = this.getMonomerSymbolsByType(polymerType);
     let monomers = monomerSymbols.map((sym) => this.getMonomer(polymerType, sym));
     monomers = monomers.filter((el) => el !== null);
@@ -116,15 +162,38 @@ export class MonomerLib implements IMonomerLib {
     this._onChanged.next();
   }
 
+  getSummaryObj(): MonomerLibSummaryType {
+    const res: MonomerLibSummaryType = {};
+    const ptList: PolymerType[] = this.getPolymerTypes();
+    for (const pt of ptList)
+      res[pt] = this.getMonomerSymbolsByType(pt).length;
+    return res;
+  }
+
+  getSummaryDf(): DG.DataFrame {
+    const ptList = this.getPolymerTypes();
+
+    const countList: number[] = new Array<number>(ptList.length);
+    for (const [pt, i] of wu.enumerate(ptList))
+      countList[i] = this.getMonomerSymbolsByType(pt).length;
+
+    const resDf: DG.DataFrame = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('polymerType', ptList),
+      DG.Column.fromList(DG.COLUMN_TYPE.INT, 'count', countList),
+    ]);
+    return resDf;
+  }
+
+  /** @deprecated Keep for backward compatibility */
   getSummary(): string {
-    const monTypeList: string[] = this.getPolymerTypes();
+    const monTypeList: PolymerType[] = this.getPolymerTypes();
     const resStr: string = monTypeList.length == 0 ? 'empty' : monTypeList.map((monType) => {
       return `${monType} ${this.getMonomerSymbolsByType(monType).length}`;
     }).join('\n');
     return resStr;
   }
 
-  getTooltip(polymerType: string, monomerSymbol: string): HTMLElement {
+  getTooltip(polymerType: PolymerType, monomerSymbol: string): HTMLElement {
     // getTooltip(monomer: Monomer): HTMLElement;
     // getTooltip(monomerOrPolymerType: string | Monomer, symbol?: string): HTMLElement {
     //   let polymerType: string;

package/src/utils/sequence-to-mol.ts

@@ -4,14 +4,16 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
-import {helm2mol} from './helm-to-molfile/utils';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
-import {checkInputColumnUI} from './check-input-column';
-import {getMonomerLibHelper} from '../package';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
-export async function sequenceToMolfile(df: DG.DataFrame, macroMolecule: DG.Column, nonlinear: boolean): Promise<void> {
+import {helm2mol} from './helm-to-molfile/utils';
+import {checkInputColumnUI} from './check-input-column';
+
+export async function sequenceToMolfile(
+  df: DG.DataFrame, macroMolecule: DG.Column, nonlinear: boolean, monomerLib: IMonomerLib
+): Promise<void> {
   if (DG.Func.find({package: 'Chem', name: 'getRdKitModule'}).length === 0) {
     grok.shell.warning('Transformation to atomic level requires package "Chem" installed.');
     return;
@@ -20,12 +22,10 @@ export async function sequenceToMolfile(df: DG.DataFrame, macroMolecule: DG.Colu
     const seqSh = SeqHandler.forColumn(macroMolecule);
     if (!seqSh.isHelm())
       macroMolecule = seqSh.convert(NOTATION.HELM);
-    helm2mol(df, macroMolecule);
-    return;
+    return helm2mol(df, macroMolecule);
   }
   if (!checkInputColumnUI(macroMolecule, 'To Atomic Level'))
     return;
-  const monomerLib: IMonomerLib = getMonomerLibHelper().getBioLib();
   const atomicLevelRes = await _toAtomicLevel(df, macroMolecule, monomerLib);
   if (atomicLevelRes.col !== null) {
     df.columns.add(atomicLevelRes.col, true);

package/src/widgets/bio-substructure-filter.ts

@@ -273,12 +273,12 @@ export class BioSubstructureFilter extends DG.Filter implements IRenderer {
   async awaitRendered(timeout: number = 10000): Promise<void> {
     const callLog = `awaitRendered( ${timeout} )`;
     const logPrefix = `${this.filterToLog()}.${callLog}`;
-    await delay(0);
+    await delay(10);
     await testEvent(this.onRendered, () => {
       this.logger.debug(`${logPrefix}, ` + '_onRendered event caught');
     }, () => {
       this.invalidate(callLog);
-    }, timeout, `${logPrefix} ${timeout} timeout`);
+    }, timeout, `${logPrefix} timeout`);
 
     // Rethrow stored syncer error (for test purposes)
     const viewErrors = this.filterSyncer.resetErrors();

package/webpack.config.js

@@ -43,6 +43,7 @@ module.exports = {
     'wu': 'wu',
     'scil': 'scil',
     'org': 'org',
+    // 'JSDraw2': 'JSDraw2',
   },
   output: {
     filename: '[name].js',