@datagrok/sequence-translator 1.4.2 → 1.4.4

package/src/polytool/pt-dialog.ts

@@ -9,9 +9,10 @@ import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
-import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
-import {doPolyToolConvert} from './pt-conversion';
+import {getRules, RuleInputs, Rules, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {doPolyToolConvert, getOverriddenLibrary} from './pt-conversion';
 import {defaultErrorHandler} from '../utils/err-info';
 import {getLibrariesList} from './utils';
 import {getEnumerationChem, PT_CHEM_EXAMPLE} from './pt-enumeration-chem';
@@ -26,6 +27,7 @@ import {_package} from '../package';
 type PolyToolConvertSerialized = {
   generateHelm: boolean;
   chiralityEngine: boolean;
+  rules: string[];
 };
 
 type PolyToolEnumerateChemSerialized = {
@@ -55,35 +57,43 @@ export async function polyToolConvertUI(): Promise<void> {
   }
 }
 
-export async function getPolyToolConvertDialog(targetCol?: DG.Column): Promise<DG.Dialog> {
+export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.Dialog> {
   const subs: Unsubscribable[] = [];
   const destroy = () => {
     for (const sub of subs) sub.unsubscribe();
   };
   try {
-    const targetColumns = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
-    if (!targetColumns)
-      throw new Error(PT_ERROR_DATAFRAME);
-
-    const targetColumnInput = ui.input.column('Column', {
-      table: grok.shell.t, value: targetColumns[0],
-      filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE
+    let srcColVal: DG.Column<string> | undefined = srcCol;
+    if (!srcColVal) {
+      const srcColList = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
+      if (srcColList.length < 1)
+        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.CUSTOM;
+      }
     });
 
-    targetColumnInput.value = targetCol ? targetCol : targetColumnInput.value;
-
-    const generateHelmChoiceInput = ui.input.bool(PT_UI_GET_HELM, {value: true});
-    ui.tooltip.bind(generateHelmChoiceInput.root, PT_UI_ADD_HELM);
+    const generateHelmInput = ui.input.bool(PT_UI_GET_HELM, {value: true});
+    ui.tooltip.bind(generateHelmInput.root, PT_UI_ADD_HELM);
 
     const chiralityEngineInput = ui.input.bool(PT_UI_USE_CHIRALITY, {value: false});
-    const ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json');
+    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]);
     ui.tooltip.bind(rulesHeader, 'Add or specify rules to use');
     const rulesForm = await ruleInputs.getForm();
 
-    const div = ui.div([
-      targetColumnInput,
-      generateHelmChoiceInput,
+    const div = ui.divV([
+      srcColInput,
+      generateHelmInput,
       chiralityEngineInput,
       rulesHeader,
       rulesForm
@@ -92,7 +102,7 @@ export async function getPolyToolConvertDialog(targetCol?: DG.Column): Promise<D
     const exec = async (): Promise<void> => {
       try {
         const ruleFileList = await ruleInputs.getActive();
-        await polyToolConvert(targetColumnInput.value!, generateHelmChoiceInput.value!, chiralityEngineInput.value!, ruleFileList);
+        await polyToolConvert(srcColInput.value!, generateHelmInput.value!, chiralityEngineInput.value!, ruleFileList);
       } catch (err: any) {
         defaultErrorHandler(err);
       }
@@ -107,13 +117,15 @@ export async function getPolyToolConvertDialog(targetCol?: DG.Column): Promise<D
     dialog.history(
       /* getInput */ (): PolyToolConvertSerialized => {
         return {
-          generateHelm: generateHelmChoiceInput.value,
+          generateHelm: generateHelmInput.value,
           chiralityEngine: chiralityEngineInput.value,
+          rules: ruleFileList,
         };
       },
       /* applyInput */ (x: PolyToolConvertSerialized): void => {
-        generateHelmChoiceInput.value = x.generateHelm;
+        generateHelmInput.value = x.generateHelm;
         chiralityEngineInput.value = x.chiralityEngine;
+        ruleInputs.setActive(ruleFileList);
       });
     return dialog;
   } catch (err: any) {
@@ -244,8 +256,11 @@ export async function polyToolConvert(
     if (generateHelm && table) table.columns.add(resHelmCol, true);
 
     const seqHelper: ISeqHelper = await getSeqHelper();
-    const toAtomicLevelRes = await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, /* highlight */ generateHelm);
+    const lib = await getOverriddenLibrary(rules);
+    const toAtomicLevelRes =
+      await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, /* highlight */ generateHelm, lib);
     const resMolCol = toAtomicLevelRes.molCol!;
+
     resMolCol.name = getUnusedName(table, `molfile(${seqCol.name})`);
     resMolCol.semType = DG.SEMTYPE.MOLECULE;
     if (table) {

package/src/polytool/pt-placeholders-breadth-input.ts

@@ -100,8 +100,8 @@ export class PolyToolPlaceholdersBreadthInput extends DG.JsInputBase<DG.DataFram
 export function dfToPlaceholdersBreadth(df: DG.DataFrame): PolyToolPlaceholdersBreadth {
   const res: PolyToolPlaceholdersBreadth = [];
   for (let rowI = 0; rowI < df.rowCount; rowI++) {
-    const startPos = parseInt(df.get('Start', rowI));
-    const endPos = parseInt(df.get('End', rowI));
+    const startPos = parseInt(df.get('Start', rowI)) - 1;
+    const endPos = parseInt(df.get('End', rowI)) - 1;
     if (!isNaN(startPos) && !isNaN(endPos)) {
       const monomerSymbolList = parseMonomerSymbolList(df.get('Monomers', rowI));
       res.push({start: startPos, end: endPos, monomers: monomerSymbolList});

package/src/polytool/pt-placeholders-input.ts

@@ -111,7 +111,7 @@ export function getPlaceholdersFromText(src: string): PolyToolPlaceholders {
 export function dfToPlaceholders(df: DG.DataFrame): PolyToolPlaceholders {
   const res: PolyToolPlaceholders = [];
   for (let rowI = 0; rowI < df.rowCount; rowI++) {
-    const pos = parseInt(df.get('Position', rowI));
+    const pos = parseInt(df.get('Position', rowI)) - 1;
     if (!isNaN(pos)) {
       const monomerSymbolList = parseMonomerSymbolList(df.get('Monomers', rowI));
       res.push({position: pos, monomers: monomerSymbolList});

package/src/polytool/pt-rules.ts

@@ -5,19 +5,24 @@ import {ActiveFiles} from '@datagrok-libraries/utils/src/settings/active-files-b
 export const RULES_PATH = 'System:AppData/SequenceTranslator/polytool-rules/';
 export const RULES_STORAGE_NAME = 'Polytool';
 export const RULES_TYPE_LINK = 'link';
+export const RULES_TYPE_REACTION = 'reaction';
 export const RULES_TYPE_HOMODIMER = 'fragmentDuplication';
 export const RULES_TYPE_HETERODIMER = 'differentFragments';
 
 export class RuleInputs extends ActiveFiles {
-  constructor(path: string, userStorageName: string, ext: string ) {
-    super(path, userStorageName, ext);
+  constructor(
+    path: string, userStorageName: string, ext: string,
+    options?: { onValueChanged: (value: string[]) => void }
+  ) {
+    super(path, userStorageName, ext, options);
   }
 }
 
 export type Rules = {
   homodimerCode: string | null,
   heterodimerCode: string | null,
-  linkRules: RuleLink[]
+  linkRules: RuleLink[],
+  reactionRules: RuleReaction[]
 }
 
 export type RuleLink = {
@@ -30,10 +35,19 @@ export type RuleLink = {
   secondLinkingGroup: number
 }
 
+export type RuleReaction = {
+  code: number,
+  firstMonomer: string,
+  secondMonomer: string,
+  reaction: string,
+  name: string
+}
+
 export async function getRules(ruleFiles: string[]): Promise<Rules> {
   const fileSource = new DG.FileSource(RULES_PATH);
   const linkRules: RuleLink[] = [];
-  const rules: Rules = {homodimerCode: null, heterodimerCode: null, linkRules: linkRules};
+  const reactionRules: RuleReaction[] = [];
+  const rules: Rules = {homodimerCode: null, heterodimerCode: null, linkRules: linkRules, reactionRules: reactionRules};
 
   for (let i = 0; i < ruleFiles.length; i++) {
     const rulesRaw = await fileSource.readAsText(ruleFiles[i].replace(RULES_PATH, ''));
@@ -47,6 +61,12 @@ export async function getRules(ruleFiles: string[]): Promise<Rules> {
           linkRules.push(rule);
           break;
         }
+        case RULES_TYPE_REACTION: {
+          const rule = ruleSingle[j].monomericSubstitution;
+          rule['code'] = ruleSingle[j].code;
+          reactionRules.push(rule);
+          break;
+        }
         case RULES_TYPE_HOMODIMER: {
           if (rules.homodimerCode)
             grok.shell.warning(`PolyTool: homodimer code is duplicated in rules.`);

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/polytool/types.ts

@@ -2,6 +2,8 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
+import {PolymerType} from '@datagrok-libraries/bio/src/helm/types';
+
 export enum PolyToolEnumeratorTypes {
   Single = 'single',
   Matrix = 'matrix',
@@ -21,3 +23,19 @@ export type PolyToolEnumeratorParams = {
   keepOriginal?: boolean;
   trivialName?: boolean;
 }
+
+export class MonomerNotFoundError extends Error {
+  public type = 'MonomerNotFoundError';
+
+  constructor(polymerType: PolymerType, symbol: string, options?: ErrorOptions) {
+    super(`Monomer '${symbol}' of polymer type '${polymerType}' not found`, options);
+  }
+}
+
+export class InvalidReactionError extends Error {
+  public type = 'InvalidReactionError';
+
+  constructor(reaction: string, options?: ErrorOptions) {
+    super(`Invalid reaction '${reaction}'.`);
+  }
+}

package/src/tests/polytool-chain-from-notation-tests.ts

@@ -0,0 +1,45 @@
+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 {Chain} from '../polytool/pt-conversion';
+import {getRules} from '../polytool/pt-rules';
+
+category('PolyTool: Chain: fromNotation', () => {
+  const tests = {
+    'cyclized': {
+      src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI'},
+      tgt: {
+        monomerCount: [11], linkageCount: 1,
+        helm: 'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$',
+      },
+    },
+    'reaction1': {
+      src: {seq: 'R-F-azG(3)-T-G-H-F-Y-P-aG(3)-meI'},
+      tgt: {
+        monomerCount: [9, 1], linkageCount: 2,
+        helm: 'PEPTIDE1{R.F.[GGaz].T.G.H.F.Y.P}|PEPTIDE2{[meI]}$PEPTIDE1,PEPTIDE1,3:R3-9:R2|PEPTIDE1,PEPTIDE2,3:R4-1:R1$$$',
+      }
+    },
+    'reaction2': {
+      src: {seq: 'R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI'},
+      tgt: {
+        // TODO: Target test data requires clarification
+        monomerCount: [2, 8], linkageCount: 0,
+        helm: 'PEPTIDE1{R.F}|PEPTIDE2{T.G.H.F.Y.P.[GGaz].[meI]}$PEPTIDE1,PEPTIDE2,2:R2-7:R3|PEPTIDE2,PEPTIDE2,1:R1-7:R4,$$$',
+      }
+    }
+
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const resChain = Chain.fromNotation(testData.src.seq, rules);
+      expectArray(resChain.monomers.map((mL) => mL.length), testData.tgt.monomerCount);
+      expect(resChain.linkages.length, testData.tgt.linkageCount);
+      expect(resChain.getHelm(), testData.tgt.helm);
+    }, testName == 'reaction2' ? {skipReason: 'reverse reaction'} : undefined);
+  }
+});

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,97 @@
+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';
+import {getNewMonomer} from '../polytool/pt-conversion';
+import {getRules, RuleReaction} from '../polytool/pt-rules';
+
+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();
+    }
+  });
+
+  test('getNewMonomer', async () => {
+    const rdKitModule = await getRdKitModule();
+    const systemMonomerLib = monomerLibHelper.getMonomerLib();
+
+    const rules = await getRules(['rules_example.json']);
+    const reactionRule = rules.reactionRules.find((r) => r.name == 'GGaz')!;
+
+    const [newSymbol, newMonomer] = getNewMonomer(rdKitModule, systemMonomerLib, reactionRule);
+    expect(newSymbol, reactionRule.name);
+
+    const mol = rdKitModule.get_mol(newMonomer.molfile);
+    try {
+      const molInchi = mol.get_inchi();
+      const molInchiKey = rdKitModule.get_inchikey_for_inchi(molInchi);
+      expect(mol.get_num_bonds(), 18);
+      expect(mol.get_num_atoms(), 18);
+      // TODO: Check inchi key for the new monomer molfile
+      // expect(molInchiKey, 'V2H10N2O3S-UHFFFAOYSA-N');
+    } finally {
+      mol.delete();
+    }
+  });
+});