@datagrok/bio 2.14.2 → 2.15.0

package/src/utils/multiple-sequence-alignment-ui.ts

@@ -70,14 +70,14 @@ export async function multipleSequenceAlignmentUI(
 
     let prevSeqCol = seqCol;
     const colInput = ui.input.column(
-      'Sequence', {table: table, value: seqCol, onValueChanged: async (input: DG.InputBase<DG.Column<string>>): Promise<void> => {
-        if (!input.value || input.value.semType !== DG.SEMTYPE.MACROMOLECULE) {
+      'Sequence', {table: table, value: seqCol, onValueChanged: async (value: DG.Column<any>) => {
+        if (!value || value.semType !== DG.SEMTYPE.MACROMOLECULE) {
           okBtn.disabled = true;
           await delay(0); // to
           colInput.value = prevSeqCol as DG.Column<string>;
           return;
         }
-        prevSeqCol = input.value;
+        prevSeqCol = value;
         okBtn.disabled = false;
         performAlignment = await onColInputChange(
           colInput.value, table, pepseaInputRootStyles, kalignInputRootStyles,

package/src/utils/seq-helper/index.ts

@@ -0,0 +1 @@
+export {SeqHelper} from './seq-helper';

package/src/utils/seq-helper/seq-helper.ts

@@ -0,0 +1,131 @@
+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 {ISeqHelper, ISubstruct, SUBSTRUCT_COL, ToAtomicLevelResType} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {RDModule, RDMol} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+
+import {HelmToMolfileConverter} from '../helm-to-molfile/converter';
+import {Column, DataFrame} from 'datagrok-api/dg';
+import {MolfileWithMap, MonomerMap} from '../helm-to-molfile/converter/types';
+
+import {_package, getMonomerLibHelper} from '../../package';
+import {MonomerLibManager} from '../monomer-lib/lib-manager';
+
+type SeqHelperWindowType = Window & { $seqHelperPromise?: Promise<SeqHelper> };
+declare const window: SeqHelperWindowType;
+
+export class SeqHelper implements ISeqHelper {
+  constructor(
+    private readonly libHelper: IMonomerLibHelper,
+    private readonly helmHelper: IHelmHelper,
+    private readonly rdKitModule: RDModule
+  ) {}
+
+  getHelmToMolfileConverter(df: DataFrame, helmCol: Column<string>) {
+    return new HelmToMolfileConverter(helmCol, df, this.libHelper, this.helmHelper);
+  }
+
+  async helmToAtomicLevel(
+    helmCol: DG.Column<string>, chiralityEngine?: boolean, highlight?: boolean
+  ): Promise<ToAtomicLevelResType> {
+    const getUnusedName = (df: DG.DataFrame | undefined, colName: string): string => {
+      if (!df) return colName;
+      return df.columns.getUnusedName(colName);
+    };
+
+    const df: DG.DataFrame = helmCol.dataFrame;
+    const molColName: string = getUnusedName(df, `molfile(${helmCol})`);
+    const molHlColName: string = getUnusedName(df, `~${molColName}-hl`);
+
+    const converter = this.getHelmToMolfileConverter(df, helmCol);
+
+    //#region From HelmToMolfileConverter.convertToRdKitBeautifiedMolfileColumn
+
+    const molfilesV3K = converter.convertToMolfileV3K(this.rdKitModule);
+
+    const beautifiedMolList: (RDMol | null)[] = molfilesV3K.map((item) => {
+      const molfile = item.molfile;
+      if (molfile === '')
+        return null;
+      const mol = this.rdKitModule.get_mol(molfile);
+      if (!mol)
+        return null;
+      mol.set_new_coords();
+      mol.normalize_depiction(1);
+      mol.straighten_depiction(true);
+      return mol;
+    });
+
+    let molList: string[];
+    if (chiralityEngine) {
+      molList = converter.getMolV3000ViaOCL(beautifiedMolList, molColName).toList();
+      // TODO: Cleanup mol objects
+    } else {
+      molList = beautifiedMolList.map((mol) => {
+        if (mol === null)
+          return '';
+        const molBlock = mol.get_v3Kmolblock();
+        mol!.delete();
+        return molBlock;
+      });
+    }
+
+    //#endregion From HelmToMolfileConverter
+
+    const molHlList = molfilesV3K.map((item: MolfileWithMap) => {
+      const mmList: MonomerMap[] = item.monomers;
+
+      const hlAtoms: { [key: number]: number[] } = {};
+      const hlBonds: { [key: number]: number[] } = {};
+
+      for (const [mm, mmI] of wu.enumerate(mmList)) {
+        if (mmI >= 2) continue;
+
+        const mmColor = [Math.random(), Math.random(), Math.random(), 0.3]; // green color
+        for (const mAtom of mm.atoms) {
+          hlAtoms[mAtom] = mmColor;
+        }
+        for (const mBond of mm.bonds) {
+          hlBonds[mBond] = mmColor;
+        }
+      }
+
+      let resSubstruct: ISubstruct = {
+        atoms: Object.keys(hlAtoms).map((k) => parseInt(k)),
+        bonds: Object.keys(hlBonds).map((k) => parseInt(k)),
+        highlightAtomColors: hlAtoms,
+        highlightBondColors: hlBonds,
+      };
+
+      return resSubstruct;
+    });
+
+    const molCol = DG.Column.fromStrings(molColName, molList);
+    molCol.semType = 'Molecule';
+    molCol.temp[SUBSTRUCT_COL] = molHlColName;
+    const molHlCol = DG.Column.fromList(DG.COLUMN_TYPE.OBJECT, molHlColName, molHlList);
+    molHlCol.semType = 'Molecule-substruct';
+
+    return {molCol: molCol, molHighlightCol: molHlCol};
+  }
+
+  static getInstance(): Promise<SeqHelper> {
+    let res = window.$seqHelperPromise;
+    if (res == undefined) {
+      res = window.$seqHelperPromise = (async () => {
+        if (!_package.initialized)
+          throw new Error('Bio package is not initialized, call Bio:getSeqHelper');
+        const instance = new SeqHelper(
+          await MonomerLibManager.getInstance(), await getHelmHelper(), _package.rdKitModule);
+        return instance;
+      })();
+    }
+    return res;
+  }
+}

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

@@ -1,4 +1,3 @@
-/* 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';
@@ -7,31 +6,61 @@ import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomi
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {getSeqHelper, ToAtomicLevelResType} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
-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) {
+): Promise<DG.Column<string> | null> {
+  let rdKitModule: RDModule;
+  try {
+    rdKitModule = await getRdKitModule();
+  } catch (ex: any) {
     grok.shell.warning('Transformation to atomic level requires package "Chem" installed.');
-    return;
+    return null;
   }
+
+  let resCol: DG.Column<string> | null = null;
   if (nonlinear) {
+    const seqHelper = await getSeqHelper();
     const seqSh = SeqHandler.forColumn(macroMolecule);
-    if (!seqSh.isHelm())
-      macroMolecule = seqSh.convert(NOTATION.HELM);
-    return helm2mol(df, macroMolecule);
-  }
-  if (!checkInputColumnUI(macroMolecule, 'To Atomic Level'))
-    return;
-  const atomicLevelRes = await _toAtomicLevel(df, macroMolecule, monomerLib);
-  if (atomicLevelRes.col !== null) {
-    df.columns.add(atomicLevelRes.col, true);
-    await grok.data.detectSemanticTypes(df);
-  }
 
-  if (atomicLevelRes.warnings && atomicLevelRes.warnings.length > 0)
-    grok.shell.warning(ui.list(atomicLevelRes.warnings));
+    let atomicLevelRes: ToAtomicLevelResType;
+
+    let helmCol: DG.Column<string>;
+    let seqColName!: string;
+    if (seqSh.isHelm())
+      helmCol = macroMolecule;
+    else {
+      seqColName = macroMolecule.name;
+      macroMolecule.name = `__${seqColName}`;
+      helmCol = seqSh.convert(NOTATION.HELM);
+      helmCol.name = seqColName;
+      df.columns.add(helmCol, false);
+    }
+    try {
+      atomicLevelRes = await seqHelper.helmToAtomicLevel(helmCol, true, true);
+    } finally {
+      if (helmCol !== macroMolecule) {
+        df.columns.remove(helmCol.name);
+        macroMolecule.name = seqColName;
+      }
+    }
+    df.columns.add(atomicLevelRes.molCol);
+    df.columns.add(atomicLevelRes.molHighlightCol);
+    resCol = atomicLevelRes.molCol;
+  } else {
+    if (!checkInputColumnUI(macroMolecule, 'To Atomic Level'))
+      return null;
+    const atomicLevelRes = await _toAtomicLevel(df, macroMolecule, monomerLib);
+    if (atomicLevelRes.col !== null) {
+      df.columns.add(atomicLevelRes.col, true);
+      resCol = atomicLevelRes.col;
+    }
+  }
+  if (resCol) await grok.data.detectSemanticTypes(df);
+  return resCol;
 }

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

@@ -296,9 +296,11 @@ export class FastaBioFilter extends BioFilterBase<BioFilterProps> {
     super();
 
     this.substructureInput = ui.input.string('', {
-      value: '', onValueChanged: () => {
-        this.props = new BioFilterProps(this.substructureInput.value);
-        if (!this._propsChanging) this.onChanged.next();
+      value: '', onValueChanged: (value) => {
+        window.setTimeout(() => {
+          this.props = new BioFilterProps(value);
+          if (!this._propsChanging) this.onChanged.next();
+        }, 0 /* next event cycle */);
       }, placeholder: 'Substructure'
     });
   }
@@ -338,14 +340,14 @@ export class SeparatorBioFilter extends BioFilterBase<SeparatorFilterProps> {
     super();
 
     this.substructureInput = ui.input.string('', {
-      value: '', onValueChanged: () => {
-        this.props = new SeparatorFilterProps(this.substructureInput.value, this.props.separator);
+      value: '', onValueChanged: (value) => {
+        this.props = new SeparatorFilterProps(value, this.props.separator);
         if (!this._propsChanging) this.onChanged.next();
       }, placeholder: 'Substructure'
     });
     this.separatorInput = ui.input.string('', {
-      value: this.colSeparator = colSeparator, onValueChanged: () => {
-        const separator: string | undefined = !!this.separatorInput.value ? this.separatorInput.value : undefined;
+      value: this.colSeparator = colSeparator, onValueChanged: (value) => {
+        const separator: string | undefined = !!value ? value : undefined;
         this.props = new SeparatorFilterProps(this.props.substructure, separator);
         if (!this._propsChanging) this.onChanged.next();
       }, placeholder: 'Separator'

package/src/widgets/package-settings-editor-widget.ts

@@ -24,9 +24,9 @@ export class PackageSettingsEditorWidget extends DG.Widget {
     const maxMonomerLengthInput = ui.input.int('Max Monomer Length', {
       value: _package.properties.maxMonomerLength!,
       nullable: true, min: 0,
-      onValueChanged: () => {
+      onValueChanged: (value) => {
         // Handle user changed value
-        _package.properties.maxMonomerLength = maxMonomerLengthInput.value ?? null;
+        _package.properties.maxMonomerLength = value ?? null;
       },
       tooltipText: this.maxMonomerLengthProp.description,
     });
@@ -34,8 +34,8 @@ export class PackageSettingsEditorWidget extends DG.Widget {
     const tooltipWebLogoInput = ui.input.bool('Tooltip WebLogo', {
       value: _package.properties.tooltipWebLogo,
       nullable: false,
-      onValueChanged: () => {
-        _package.properties.tooltipWebLogo = tooltipWebLogoInput.value!;
+      onValueChanged: (value) => {
+        _package.properties.tooltipWebLogo = value;
       },
       tooltipText: this.tooltipWebLogo.description,
     });
@@ -43,8 +43,8 @@ export class PackageSettingsEditorWidget extends DG.Widget {
     const defaultSeparatorInput = ui.input.choice('Default Separator', {
       value: _package.properties.defaultSeparator,
       items: ['.', '/', '-'],
-      onValueChanged: () => {
-        _package.properties.defaultSeparator = defaultSeparatorInput.value!;
+      onValueChanged: (value) => {
+        _package.properties.defaultSeparator = value;
       },
       tooltipText: this.defaultSeparator.description,
     });

package/src/widgets/representations.ts

@@ -37,12 +37,12 @@ export function getMacromoleculeColumnPropertyPanel(col: DG.Column): DG.Widget {
   const maxMonomerLengthInput = ui.input.int('Max Monomer Length', {
     value: maxMonomerLength!,
     nullable: true, min: 1, max: 50, step: 1,
-    onValueChanged: () => {
-      if (maxMonomerLengthInput.value == 0)
+    onValueChanged: (value) => {
+      if (value == 0)
         setTimeout(() => { maxMonomerLengthInput.value = null!; }, 0);
       else {
-        const value = maxMonomerLengthInput.value ?? '';
-        const tagValue = value == null ? '' : value.toString();
+        const newValue = value ?? '';
+        const tagValue = newValue == null ? '' : newValue.toString();
         col.temp[Temps.maxMonomerLength] = tagValue;
         col.temp[Temps.rendererSettingsChanged] = rendererSettingsChangedState.true;
         col.dataFrame.fireValuesChanged();
@@ -53,8 +53,8 @@ export function getMacromoleculeColumnPropertyPanel(col: DG.Column): DG.Widget {
 
   const gapLengthInput = ui.input.int('Monomer Margin', {
     value: col.temp[mmcrTemps.gapLength] ?? 0,
-    onValueChanged: () => {
-      col.temp[mmcrTemps.gapLength] = gapLengthInput.value;
+    onValueChanged: (value) => {
+      col.temp[mmcrTemps.gapLength] = value;
       col.temp[mmcrTemps.rendererSettingsChanged] = rendererSettingsChangedState.true;
       col.dataFrame.fireValuesChanged();
     },
@@ -63,8 +63,8 @@ export function getMacromoleculeColumnPropertyPanel(col: DG.Column): DG.Widget {
 
   const colorCodeInput = ui.input.bool('Color Code', {
     value: (col?.temp['color-code'] != null) ? col.temp['color-code'] : true,
-    onValueChanged: () => {
-      col.temp['color-code'] = colorCodeInput.value;
+    onValueChanged: (value) => {
+      col.temp['color-code'] = value;
       col.dataFrame.fireValuesChanged();
     },
     tooltipText: 'Color code'
@@ -73,8 +73,8 @@ export function getMacromoleculeColumnPropertyPanel(col: DG.Column): DG.Widget {
   const referenceSequenceInput = ui.input.string('Reference Sequence', {
     value: (col?.temp['reference-sequence'] != null) ? col?.temp['reference-sequence'] : '',
     nullable: true,
-    onValueChanged: () => {
-      col.temp['reference-sequence'] = referenceSequenceInput.value;
+    onValueChanged: (value) => {
+      col.temp['reference-sequence'] = value;
       col.dataFrame.fireValuesChanged();
     },
     tooltipText: 'Reference sequence is not empty, then the sequence will be render ' + '\n' +
@@ -83,8 +83,8 @@ export function getMacromoleculeColumnPropertyPanel(col: DG.Column): DG.Widget {
 
   const compareWithCurrentInput = ui.input.bool('Compare with current', {
     value: (col?.temp['compare-with-current'] != null) ? col.temp['compare-with-current'] : true,
-    onValueChanged: () => {
-      col.temp['compare-with-current'] = compareWithCurrentInput.value;
+    onValueChanged: (value) => {
+      col.temp['compare-with-current'] = value;
       col.dataFrame.fireValuesChanged();
     },
     tooltipText: 'When on, all sequences get rendered in the "diff" mode'