@datagrok/sequence-translator 1.4.2 → 1.4.3

package/src/polytool/pt-unrule-dialog.ts

@@ -0,0 +1,106 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {Unsubscribable} from 'rxjs';
+
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {getUnusedColName} from '@datagrok-libraries/bio/src/monomer-works/utils';
+
+import {defaultErrorHandler} from '../utils/err-info';
+import {doPolyToolUnrule} from './pt-unrule';
+import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {PT_ERROR_DATAFRAME, PT_UI_DIALOG_UNRULE, PT_UI_RULES_USED} from './const';
+
+type PolyToolUnruleSerialized = {
+  rules: string[];
+};
+
+export async function getPolyToolUnruleDialog(srcCol?: DG.Column<string>): Promise<DG.Dialog> {
+  const subs: Unsubscribable[] = [];
+  const destroy = () => {
+    for (const sub of subs) sub.unsubscribe();
+  };
+  try {
+    let srcColVal: DG.Column<string> | undefined = srcCol;
+    if (!srcColVal) {
+      const srcColList = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
+      if (!srcColList)
+        throw new Error(PT_ERROR_DATAFRAME);
+      srcColVal = srcColList[0];
+    }
+    const srcColInput = ui.input.column('Column', {
+      table: srcColVal.dataFrame, value: srcColVal,
+      filter: (col: DG.Column) => {
+        if (col.semType !== DG.SEMTYPE.MACROMOLECULE) return false;
+        const sh = SeqHandler.forColumn(col);
+        return sh.notation === NOTATION.HELM;
+      }
+    });
+    let ruleFileList: string[];
+    const ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json', {
+      onValueChanged: (value: string[]) => { ruleFileList = value;}
+    });
+    const rulesHeader = ui.inlineText([PT_UI_RULES_USED]);
+    const rulesForm = await ruleInputs.getForm();
+
+    const div = ui.divV([
+      srcColInput,
+      rulesHeader,
+      rulesForm
+    ]);
+
+    const exec = async (): Promise<void> => {
+      try {
+        const ruleFileList = await ruleInputs.getActive();
+        await polyToolUnrule(srcColInput.value!, ruleFileList);
+      } catch (err: any) {
+        defaultErrorHandler(err);
+      }
+    };
+
+    const dialog = ui.dialog(PT_UI_DIALOG_UNRULE)
+      .add(div)
+      .onOK(() => { exec(); });
+    subs.push(dialog.onClose.subscribe(() => {
+      destroy();
+    }));
+    dialog.history(
+      /* getInput */ (): PolyToolUnruleSerialized => {
+        return {
+          rules: ruleFileList,
+        };
+      },
+      /* applyInput */ (x: PolyToolUnruleSerialized): void => {
+        ruleInputs.setActive(ruleFileList);
+      });
+    return dialog;
+  } catch (err: any) {
+    destroy(); // on failing to build a dialog
+    throw err;
+  }
+}
+
+export async function polyToolUnrule(
+  srcCol: DG.Column<string>, ruleFiles: string[]
+): Promise<DG.Column> {
+  const pi = DG.TaskBarProgressIndicator.create('PolyTool unrule...');
+  try {
+    const table = srcCol.dataFrame;
+    const rules = await getRules(ruleFiles);
+    const resHelmList = doPolyToolUnrule(srcCol.toList(), rules);
+    const resHelmColName = `harmonized(srcCol.name)`;
+    const resHelmCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, resHelmColName, resHelmList,);
+    resHelmCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    resHelmCol.meta.units = NOTATION.CUSTOM;
+    if (table) {
+      resHelmCol.name = getUnusedColName(table, resHelmColName);
+      table.columns.add(resHelmCol, true);
+      await grok.data.detectSemanticTypes(table);
+    }
+    return resHelmCol;
+  } finally {
+    pi.close();
+  }
+}

package/src/polytool/pt-unrule.ts

@@ -0,0 +1,37 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+
+import {Chain} from './pt-conversion';
+import {getPolyToolUnruleDialog} from './pt-unrule-dialog';
+import {Rules} from './pt-rules';
+
+import {_package} from '../package';
+
+export async function polyToolUnruleUI(): Promise<void> {
+  let dialog: DG.Dialog;
+  try {
+    dialog = await getPolyToolUnruleDialog();
+    dialog.show();
+  } catch (err: any) {
+    const [errMsg, errStack] = errInfo(err);
+    grok.shell.warning('To run PolyTool Unrule, open a dataframe with Helm');
+    _package.logger.error(errMsg, undefined, errStack);
+  }
+}
+
+/** Returns list of harmonized sequences. Covered with tests. */
+export function doPolyToolUnrule(helms: string[], rules: Rules): string[] {
+  const resHrzSeqList = new Array<string>(helms.length);
+  for (let i = 0; i < helms.length; ++i) {
+    if (!helms[i])
+      resHrzSeqList[i] = '';
+    else {
+      const chain = Chain.fromHelm(helms[i]);
+      resHrzSeqList[i] = chain.getNotation(rules);
+    }
+  }
+  return resHrzSeqList;
+}

package/src/tests/polytool-convert-tests.ts

@@ -6,7 +6,7 @@ import {before, after, category, expect, test, expectArray, testEvent, delay} fr
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {
-  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
@@ -23,9 +23,8 @@ category('PolyTool: Convert', () => {
   before(async () => {
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
-    // Clear settings to test default
-    await setUserLibSettingsForTests();
-    await monomerLibHelper.loadMonomerLib(true);
+
+    await monomerLibHelper.loadMonomerLibForTests();
   });
 
   after(async () => {
@@ -43,11 +42,11 @@ category('PolyTool: Convert', () => {
         'R-F-D(2)-T-G-H-F-Y-P-NH2(2)',
       ],
       tgt: [
-        'PEPTIDE1{[R].[F].[C].[T].[G].[H].[F].[Y].[P].[C].[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$',
-        'PEPTIDE1{[C].[T].[G].[H].[F].[Y].[P].[C].[meI]}$PEPTIDE1,PEPTIDE1,1:R3-8:R3$$$',
-        'PEPTIDE1{[R].[F].[C].[T].[G].[H].[F].[Y].[P].[C]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$',
-        'PEPTIDE1{[C].[T].[G].[H].[F].[H].[P].[C]}$PEPTIDE1,PEPTIDE1,1:R3-8:R3$$$',
-        'PEPTIDE1{[R].[F].[D].[T].[G].[H].[F].[Y].[P].[NH2]}$PEPTIDE1,PEPTIDE1,10:R2-3:R3$$$',
+        'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$',
+        'PEPTIDE1{C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,1:R3-8:R3$$$',
+        'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$',
+        'PEPTIDE1{C.T.G.H.F.H.P.C}$PEPTIDE1,PEPTIDE1,1:R3-8:R3$$$',
+        'PEPTIDE1{R.F.D.T.G.H.F.Y.P.[NH2]}$PEPTIDE1,PEPTIDE1,10:R2-3:R3$$$',
       ]
     }
   };

package/src/tests/polytool-enumerate-breadth-tests.ts

@@ -7,7 +7,7 @@ import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {
-  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 
 import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes} from '../polytool/types';
@@ -25,10 +25,8 @@ category('PolyTool: Enumerate', () => {
 
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
-    // Clear settings to test default
-    await setUserLibSettingsForTests();
-    await monomerLibHelper.awaitLoaded();
-    await monomerLibHelper.loadMonomerLib(true);
+
+    await monomerLibHelper.loadMonomerLibForTests();
   });
 
   after(async () => {

package/src/tests/polytool-enumerate-tests.ts

@@ -7,7 +7,7 @@ import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {
-  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 
 import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes} from '../polytool/types';
@@ -26,9 +26,7 @@ category('PolyTool: Enumerate', () => {
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
     // Clear settings to test default
-    await setUserLibSettingsForTests();
-    await monomerLibHelper.awaitLoaded();
-    await monomerLibHelper.loadMonomerLib(true);
+    await monomerLibHelper.loadMonomerLibForTests();
   });
 
   after(async () => {

package/src/tests/polytool-unrule-tests.ts

@@ -0,0 +1,10 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
+
+import {doPolyToolUnrule} from '../polytool/pt-unrule';
+import {getRules} from '../polytool/pt-rules';
+
+import {_package} from '../package-test';

package/src/tests/toAtomicLevel-tests.ts

@@ -0,0 +1,72 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
+import {Monomer, MonomerLibData} from '@datagrok-libraries/bio/src/types/index';
+
+import {PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
+import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+
+import {_package} from '../package-test';
+
+category('toAtomicLevel', () => {
+  let userLibSettings: UserLibSettings;
+  let monomerLibHelper: IMonomerLibHelper;
+  let rdKitModule: RDModule;
+
+  before(async () => {
+
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibSettings = await getUserLibSettings();
+    rdKitModule = await getRdKitModule();
+
+    await monomerLibHelper.loadMonomerLibForTests();
+  });
+
+  after(async () => {
+    await setUserLibSettings(userLibSettings);
+    await monomerLibHelper.loadMonomerLib(true); // load user settings libraries
+  });
+
+  test('override', async () => {
+    const systemMonomerLib = monomerLibHelper.getMonomerLib();
+    const rLibStr = await _package.files.readAsText('tests/polytool-reaction-lib.json');
+    const rLib: Monomer[] = JSON.parse(rLibStr);
+    const ggazM = rLib.find((m) => m.symbol === 'GGaz')!;
+    expect(ggazM != null, true, `Monomer 'GGaz' not found.`);
+
+    const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: {'GGaz': ggazM}};
+    const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData);
+
+    const seqHelper = await getSeqHelper();
+
+    const helmCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'helm',
+      ['PEPTIDE1{F.P.Y.[GGaz].H.A.A.G.G.A.C}|PEPTIDE2{A.A.A}$PEPTIDE1,PEPTIDE2,4:R4-1:R1|PEPTIDE1,PEPTIDE1,11:R2-4:R3$$$V2.0']);
+    helmCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    helmCol.meta.units = NOTATION.HELM;
+    const talRes = await seqHelper.helmToAtomicLevel(helmCol, false, false, overriddenMonomerLib);
+
+    expect(talRes.molCol != null, true, 'Result molCol is null');
+    const molfile = talRes.molCol!.get(0)!;
+    expect(!!molfile, true, 'Molfile is empty');
+
+    const mol = rdKitModule.get_mol(molfile);
+    try {
+      const molInchi = mol.get_inchi();
+      const molInchiKey = rdKitModule.get_inchikey_for_inchi(molInchi);
+
+      expect(mol.get_num_bonds(), 103);
+      expect(mol.get_num_atoms(), 98);
+      expect(molInchiKey, 'XPQUTLNSNIMERR-WKBTUBAPSA-N');
+    } finally {
+      mol.delete();
+    }
+  });
+});