@datagrok/bio 2.15.13 → 2.16.0

package/src/tests/detectors-tests.ts

@@ -2,13 +2,12 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {category, test, expect} from '@datagrok-libraries/utils/src/test';
+import {category, test, expect, before} from '@datagrok-libraries/utils/src/test';
 
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {_testNeg, _testPos, DetectorTestData, DfReaderFunc, PosCol} from './utils/detectors-utils';
-import {importFasta} from '../package';
 
 /*
 // snippet to list df columns of semType='Macromolecule' (false positive)
@@ -22,6 +21,12 @@ for (let i = 0; i < df.columns.length; i++) {
  */
 
 category('detectors', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   const enum csvTests {
     fastaDna1 = 'csvFastaDna1',
     fastaRna1 = 'fastaRna1',
@@ -177,7 +182,7 @@ PEPTIDE1{Ad(1).S.W.Y.C.K.H.P.M.W.A.A.A.A.C(1)-G-NH2}$$$$`,
       for (const negColName of testData.neg ?? [])
         await _testNeg(reader, negColName);
       for (const [posColName, posCol] of Object.entries(testData.pos ?? {})) {
-        await _testPos(reader, posColName, posCol.units, posCol.aligned,
+        await _testPos(reader, posColName, seqHelper, posCol.units, posCol.aligned,
           posCol.alphabet, posCol.alphabetSize, posCol.alphabetIsMultichar, posCol.separator);
       }
     });
@@ -318,7 +323,7 @@ MWRSWY-CKHPMWRSWY-CKHP`;
 
   async function _readFileFasta(file: string): Promise<DG.DataFrame> {
     const txt: string = await grok.dapi.files.readAsText(file);
-    const df: DG.DataFrame = importFasta(txt)[0];
+    const df: DG.DataFrame = (await grok.functions.call('Bio.importFasta', {fileContent: txt}))[0] as DG.DataFrame;
     return df;
   }
 
@@ -336,77 +341,77 @@ MWRSWY-CKHPMWRSWY-CKHP`;
   test('NegativeStartEndIntermediate', async () => { await _testNegList(['START', 'END', 'INTERMEDIATE']); });
 
   test('FastaDna1', async () => {
-    await _testPos(readCsv(csvTests.fastaDna1), 'seq',
+    await _testPos(readCsv(csvTests.fastaDna1), 'seq', seqHelper,
       NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.DNA, 4, false);
   });
   test('FastaRna1', async () => {
-    await _testPos(readCsv(csvTests.fastaRna1), 'seq',
+    await _testPos(readCsv(csvTests.fastaRna1), 'seq', seqHelper,
       NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.RNA, 4, false);
   });
   test('FastaPt1', async () => {
-    await _testPos(readCsv(csvTests.fastaPt1), 'seq',
+    await _testPos(readCsv(csvTests.fastaPt1), 'seq', seqHelper,
       NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false);
   });
-  test('FastaPtGaps', () => _testPosList(['FW-PH-EYY', 'FYNRQWYV-', 'FKP-Q-SEYV'],
+  test('FastaPtGaps', () => _testPosList(['FW-PH-EYY', 'FYNRQWYV-', 'FKP-Q-SEYV'], seqHelper,
     NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false));
-  test('FastaPtGapsMsa', () => _testPosList(['FW-PH-EYY', 'FYNRQWYV-', 'FKP-Q-SEY'],
+  test('FastaPtGapsMsa', () => _testPosList(['FW-PH-EYY', 'FYNRQWYV-', 'FKP-Q-SEY'], seqHelper,
     NOTATION.FASTA, ALIGNMENT.SEQ_MSA, ALPHABET.PT, 20, false));
 
   test('FastaUn', async () => {
-    await _testPos(readCsv(csvTests.fastaUn), 'seq',
+    await _testPos(readCsv(csvTests.fastaUn), 'seq', seqHelper,
       NOTATION.FASTA, ALIGNMENT.SEQ_MSA, ALPHABET.UN, 12, true);
   });
 
   test('FastaMsaDna1', async () => {
-    await _testPos(readCsv(csvTests.fastaMsaDna1), 'seq',
+    await _testPos(readCsv(csvTests.fastaMsaDna1), 'seq', seqHelper,
       NOTATION.FASTA, ALIGNMENT.SEQ_MSA, ALPHABET.DNA, 4, false);
   });
 
   test('FastaMsaPt1', async () => {
-    await _testPos(readCsv(csvTests.fastaMsaPt1), 'seq',
+    await _testPos(readCsv(csvTests.fastaMsaPt1), 'seq', seqHelper,
       NOTATION.FASTA, ALIGNMENT.SEQ_MSA, ALPHABET.PT, 20, false);
   });
 
   test('SepDna', async () => {
-    await _testPos(readCsv(csvTests.sepDna), 'seq',
+    await _testPos(readCsv(csvTests.sepDna), 'seq', seqHelper,
       NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.DNA, 4, false, '*');
   });
   test('SepRna', async () => {
-    await _testPos(readCsv(csvTests.sepRna), 'seq',
+    await _testPos(readCsv(csvTests.sepRna), 'seq', seqHelper,
       NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.RNA, 4, false, '*');
   });
   test('SepPt', async () => {
-    await _testPos(readCsv(csvTests.sepPt), 'seq',
+    await _testPos(readCsv(csvTests.sepPt), 'seq', seqHelper,
       NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.PT, 20, false, '-');
   });
   test('SepUn1', async () => {
-    await _testPos(readCsv(csvTests.sepUn1), 'seq',
+    await _testPos(readCsv(csvTests.sepUn1), 'seq', seqHelper,
       NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.UN, 8, true, '-');
   });
   test('SepUn2', async () => {
-    await _testPos(readCsv(csvTests.sepUn2), 'seq',
+    await _testPos(readCsv(csvTests.sepUn2), 'seq', seqHelper,
       NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.UN, 9, true, '/');
   });
 
   test('SepMsaN1', async () => {
-    await _testPos(readCsv(csvTests.sepMsaDna1), 'seq',
+    await _testPos(readCsv(csvTests.sepMsaDna1), 'seq', seqHelper,
       NOTATION.SEPARATOR, ALIGNMENT.SEQ_MSA, ALPHABET.DNA, 4, false, '-');
   });
 
   test('SepMsaUnWEmpty', async () => {
-    await _testPos(readCsv(csvTests.sepMsaUnWEmpty), 'seq',
+    await _testPos(readCsv(csvTests.sepMsaUnWEmpty), 'seq', seqHelper,
       NOTATION.SEPARATOR, ALIGNMENT.SEQ_MSA, ALPHABET.UN, 14, true);
   });
 
   test('SepComplex', async () => {
-    await _testPos(readCsv(csvTests.sepComplex), 'seq',
+    await _testPos(readCsv(csvTests.sepComplex), 'seq', seqHelper,
       NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.UN, 17, true);
   });
 
   test('samplesFastaCsv', async () => {
     await _testDf(readSamples(Samples.fastaCsv), {
       'Sequence': new PosCol(NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false),
-    });
+    }, seqHelper);
   });
 
   // test('samplesFastaFasta', async () => {
@@ -420,27 +425,27 @@ MWRSWY-CKHPMWRSWY-CKHP`;
   //   await _testPos(readSamples(Samples.peptidesComplex), 'AlignedSequence', 'separator:SEQ:UN', '-');
   // });
   test('samplesPeptidesComplex', async () => {
-    await _testDf(readSamples(Samples.peptidesComplex), {} /* no positive */);
+    await _testDf(readSamples(Samples.peptidesComplex), {} /* no positive */, seqHelper);
   });
 
   test('samplesMsaComplex', async () => {
     await _testDf(readSamples(Samples.msaComplex), {
       'MSA': new PosCol(NOTATION.SEPARATOR, ALIGNMENT.SEQ_MSA, ALPHABET.UN, 161, true, '/'),
-    });
+    }, seqHelper);
   });
 
   test('samplesIdCsv', async () => {
-    await _testDf(readSamples(Samples.testIdCsv), {} /* no positive */);
+    await _testDf(readSamples(Samples.testIdCsv), {} /* no positive */, seqHelper);
   });
 
   test('samplesSarSmallCsv', async () => {
-    await _testDf(readSamples(Samples.testSmilesCsv), {} /* nopositive */);
+    await _testDf(readSamples(Samples.testSmilesCsv), {} /* nopositive */, seqHelper);
   });
 
   test('samplesHelmCsv', async () => {
     await _testDf(readSamples(Samples.helmCsv), {
       'HELM': new PosCol(NOTATION.HELM, null, null, 160, true),
-    });
+    }, seqHelper);
   });
 
   // sample_testHelm.csv
@@ -448,57 +453,57 @@ MWRSWY-CKHPMWRSWY-CKHP`;
   test('samplesTestHelmCsv', async () => {
     await _testDf(readSamples(Samples.testHelmCsv), {
       'HELM string': new PosCol(NOTATION.HELM, null, null, 9, true),
-    });
+    }, seqHelper);
   });
 
   test('samplesTestDemogCsv', async () => {
-    await _testDf(readSamples(Samples.testDemogCsv), {} /* no positive */);
+    await _testDf(readSamples(Samples.testDemogCsv), {} /* no positive */, seqHelper);
   });
 
   test('samplesTestSmiles2Csv', async () => {
-    await _testDf(readSamples(Samples.testSmiles2Csv), {} /* no positive */);
+    await _testDf(readSamples(Samples.testSmiles2Csv), {} /* no positive */, seqHelper);
   });
 
   test('samplesTestSmilesShort', async () => {
-    await _testDf(readSamples(Samples.testSmilesShort), {} /* no positive */);
+    await _testDf(readSamples(Samples.testSmilesShort), {} /* no positive */, seqHelper);
   });
 
   test('samplesTestActivityCliffsNegativeSmiles', async () => {
-    await _testDf(readSamples(Samples.testActivityCliffsCsv), {} /* no positive */);
+    await _testDf(readSamples(Samples.testActivityCliffsCsv), {} /* no positive */, seqHelper);
   });
 
   test('samplesFastaPtCsv', async () => {
     await _testDf(readSamples(Samples.fastaPtCsv), {
       'sequence': new PosCol(NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false),
-    });
+    }, seqHelper);
   });
 
   test('samplesTestCerealCsv', async () => {
-    await _testDf(readSamples(Samples.testCerealCsv), {} /* no positive */);
+    await _testDf(readSamples(Samples.testCerealCsv), {} /* no positive */, seqHelper);
   });
 
   test('samplesTestUnichemSources', async () => {
-    await _testDf(readSamples(Samples.testUnichemSources), {} /* no positive */);
+    await _testDf(readSamples(Samples.testUnichemSources), {} /* no positive */, seqHelper);
   });
 
   test('samplesTestDmvOffices', async () => {
-    await _testDf(readSamples(Samples.testDmvOffices), {} /* no positive */);
+    await _testDf(readSamples(Samples.testDmvOffices), {} /* no positive */, seqHelper);
   });
 
   test('samplesTestAlertCollection', async () => {
-    await _testDf(readSamples(Samples.testAlertCollection), {} /* no positive */);
+    await _testDf(readSamples(Samples.testAlertCollection), {} /* no positive */, seqHelper);
   });
 
   test('samplesTestSpgi', async () => {
-    await _testDf(readSamples(Samples.testSpgi), {} /* no positive */);
+    await _testDf(readSamples(Samples.testSpgi), {} /* no positive */, seqHelper);
   });
 
   test('samplesTestSpgi100', async () => {
-    await _testDf(readSamples(Samples.testSpgi100), {} /* no positive */);
+    await _testDf(readSamples(Samples.testSpgi100), {} /* no positive */, seqHelper);
   });
 
   test('samplesTestUrl', async () => {
-    await _testDf(readSamples(Samples.testUrl), {} /* no positive */);
+    await _testDf(readSamples(Samples.testUrl), {} /* no positive */, seqHelper);
   });
 });
 
@@ -511,7 +516,7 @@ export async function _testNegList(list: string[]): Promise<void> {
   }
 }
 
-export async function _testPosList(list: string[], units: NOTATION,
+export async function _testPosList(list: string[], seqHelper: ISeqHelper, units: NOTATION,
   aligned: ALIGNMENT, alphabet: ALPHABET, alphabetSize: number, alphabetIsMultichar: boolean,
   separator: string | null = null
 ): Promise<void> {
@@ -527,7 +532,7 @@ export async function _testPosList(list: string[], units: NOTATION,
   if (separator)
     expect(col.getTag(bioTAGS.separator), separator);
 
-  const sh = SeqHandler.forColumn(col);
+  const sh = seqHelper.getSeqHandler(col);
   expect(sh.getAlphabetSize(), alphabetSize);
   expect(sh.getAlphabetIsMultichar(), alphabetIsMultichar);
   if (!sh.isHelm()) {
@@ -536,14 +541,16 @@ export async function _testPosList(list: string[], units: NOTATION,
   }
 }
 
-export async function _testDf(readDf: DfReaderFunc, posCols: { [colName: string]: PosCol }): Promise<void> {
+export async function _testDf(
+  readDf: DfReaderFunc, posCols: { [colName: string]: PosCol }, seqHelper: ISeqHelper
+): Promise<void> {
   const df: DG.DataFrame = await readDf();
   const errList: string[] = [];
   for (const colName of df.columns.names()) {
     if (colName in posCols) {
       const p = posCols[colName];
       try {
-        await _testPos(readDf, colName, p.units, p.aligned, p.alphabet,
+        await _testPos(readDf, colName, seqHelper, p.units, p.aligned, p.alphabet,
           p.alphabetSize, p.alphabetIsMultichar, p.separator);
       } catch (err: any) {
         const errMsg: string = err.toString();

package/src/tests/detectors-weak-and-likely-tests.ts

@@ -2,13 +2,20 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {category, test} from '@datagrok-libraries/utils/src/test';
+import {before, category, test} from '@datagrok-libraries/utils/src/test';
 import {ALIGNMENT, ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {_testNeg, _testPos, DfReaderFunc} from './utils/detectors-utils';
 
 
-category('detectors:weak-and-likely', () => {
+category('detectors.weak-and-likely', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   const enum csvTests {
     fastaDnaWeak1 = 'fastaDnaWeak1',
     fastaDnaWeak1LikelyName = 'fastaDnaWeak1LikelyName',
@@ -92,7 +99,7 @@ Megafantastic
     await _testNeg(readCsv(csvTests.fastaDnaWeak1), 'colName');
   });
   test(csvTests.fastaDnaWeak1LikelyName, async () => {
-    await _testPos(readCsv(csvTests.fastaDnaWeak1LikelyName), 'seq',
+    await _testPos(readCsv(csvTests.fastaDnaWeak1LikelyName), 'seq', seqHelper,
       NOTATION.FASTA, ALIGNMENT.SEQ_MSA, ALPHABET.DNA, 4, false);
   });
 
@@ -100,7 +107,7 @@ Megafantastic
     await _testNeg(readCsv(csvTests.fastaRnaWeak1), 'colName');
   });
   test(csvTests.fastaRnaWeak1LikelyName, async () => {
-    await _testPos(readCsv(csvTests.fastaRnaWeak1LikelyName), 'seq',
+    await _testPos(readCsv(csvTests.fastaRnaWeak1LikelyName), 'seq', seqHelper,
       NOTATION.FASTA, ALIGNMENT.SEQ_MSA, ALPHABET.RNA, 4, false);
   });
 
@@ -108,7 +115,7 @@ Megafantastic
     await _testNeg(readCsv(csvTests.fastaPtWeak1), 'colName');
   });
   test(csvTests.fastaPtWeak1LikelyName, async () => {
-    await _testPos(readCsv(csvTests.fastaPtWeak1LikelyName), 'seq',
+    await _testPos(readCsv(csvTests.fastaPtWeak1LikelyName), 'seq', seqHelper,
       NOTATION.FASTA, ALIGNMENT.SEQ_MSA, ALPHABET.PT, 20, false);
   });
 

package/src/tests/fasta-export-tests.ts

@@ -2,14 +2,21 @@ import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 
-import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+
 import {saveAsFastaDo, wrapSequence} from '../utils/save-as-fasta';
-import {NOTATION, splitterAsFasta} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
 type SaveAsFastaTestArgs = { srcCsv: string, idCols: string [], seqCol: string, lineWidth: number, tgtFasta: string };
 
 category('fastaExport', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   enum WrapDataTest {
     single = 'single',
     multi = 'multi'
@@ -92,7 +99,7 @@ MRGGL
     const col = DG.Column.fromStrings('src', [srcSeq]);
     col.semType = DG.SEMTYPE.MACROMOLECULE;
     col.meta.units = NOTATION.FASTA;
-    const sh = SeqHandler.forColumn(col);
+    const sh = seqHelper.getSeqHandler(col);
     const srcSS = sh.getSplitted(0);
     const wrapRes: string[] = wrapSequence(srcSS, lineWidth);
     const wrapTgt: string[] = wrapData[testKey].tgt;
@@ -108,7 +115,8 @@ MRGGL
     seqCol.meta.units = NOTATION.FASTA;
     const idCols: DG.Column[] = args.idCols.map((colName) => df.getCol(colName));
 
-    const fastaRes: string = saveAsFastaDo(idCols, seqCol, args.lineWidth);
+    const seqHandler = seqHelper.getSeqHandler(seqCol);
+    const fastaRes: string = saveAsFastaDo(idCols, seqHandler, args.lineWidth);
     expect(fastaRes, args.tgtFasta);
   }
 });

package/src/tests/helm-tests.ts

@@ -0,0 +1,85 @@
+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 {before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {Helm} from '../utils/helm-to-molfile/converter/helm';
+
+category('helm', () => {
+  const tests = {
+    'single-linear': {
+      src: {helm: 'PEPTIDE1{R.F.Y.[GGaz].T.[meI]}$$$$'},
+      tgt: {
+        simplePolymers: [6],
+        bondedRGroups: [1, 2, 2, 2, 2, 1],
+      }
+    },
+    'single-cyclized-C-2-2': {
+      src: {helm: 'PEPTIDE1{R.F.C.Y.G.H.[GGaz].C.T.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-8,R3$$$'},
+      tgt: {
+        simplePolymers: [10],
+        bondedRGroups: [1, 2, 3, 2, 2, 2, 2, 3, 2, 1],
+      }
+    },
+    'single-cyclized-C-1-1': {
+      src: {helm: 'PEPTIDE1{F.C.Y.G.H.[GGaz].C.[meI]}$PEPTIDE1,PEPTIDE1,2:R3-7,R3$$$'},
+      tgt: {
+        simplePolymers: [8],
+        bondedRGroups: [1, 3, 2, 2, 2, 1, 3, 1],
+      }
+    },
+    'single-cyclized-C-0-0': {
+      src: {helm: 'PEPTIDE1{C.Y.G.H.[GGaz].C}$PEPTIDE1,PEPTIDE1,2:R3-7,R3$$$'},
+      tgt: {
+        simplePolymers: [6],
+        bondedRGroups: [2, 2, 2, 2, 2, 2],
+      }
+    },
+    'two-separated-1': {
+      src: {helm: 'PEPTIDE1{R.F.Y.[GGaz].T}|PEPTIDE2{[meI]}$$$$'},
+      tgt: {
+        simplePolymers: [5, 1],
+        bondedRGroups: [1, 2, 2, 2, 1, 1],
+      }
+    },
+    'two-separated-2': {
+      src: {helm: 'PEPTIDE1{R.F.Y.[GGaz]}|PEPTIDE2{T.[meI]}$$$$'},
+      tgt: {
+        simplePolymers: [4, 2],
+        bondedRGroups: [1, 2, 2, 1, 1, 1],
+      }
+    },
+    'two-connected-1': {
+      src: {helm: 'PEPTIDE1{R.F.Y.[GGaz].T}|PEPTIDE2{[meI]}$PEPTIDE1,PEPTIDE2,5:R2-1,R1$$$'},
+      tgt: {
+        simplePolymers: [5, 1],
+        bondedRGroups: [1, 2, 2, 2, 2, 1],
+      }
+    },
+    'two-connected-2': {
+      src: {helm: 'PEPTIDE1{R.F.Y.[GGaz]}|PEPTIDE2{T.[meI]}$PEPTIDE1,PEPTIDE2,4:R2-1,R1$$$'},
+      tgt: {
+        simplePolymers: [4, 2],
+        bondedRGroups: [1, 2, 2, 2, 2, 1],
+      }
+    }
+  };
+
+  for (const [testName, {src, tgt}] of Object.entries(tests)) {
+    test(testName, async () => {
+      const resHelm = new Helm(src.helm);
+
+      const simplePolymers = resHelm.simplePolymers
+        .map((sp) => sp.monomers.length);
+      const totalMonomerCount = simplePolymers.reduce((a, b) => a + b, 0);
+      expect(simplePolymers, tgt.simplePolymers);
+
+      const bondedRGroups = wu.count(0).take(resHelm.bondedRGroupsMap.size)
+        .map((i) => resHelm.bondedRGroupsMap.get(i)!.length).toArray();
+      expect(totalMonomerCount, bondedRGroups.length);
+      // expectArray(bondedRGroups, tgt.bondedRGroups);
+    }, {skipReason: 'new tests'});
+  }
+});

package/src/tests/mm-distance-tests.ts

@@ -2,12 +2,19 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {category, expect, test} from '@datagrok-libraries/utils/src/test';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {before, category, expect, test} from '@datagrok-libraries/utils/src/test';
+import {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {MmDistanceFunctionsNames, mmDistanceFunctions}
   from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 
 category('Distance', async () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   const scoringMatrix = [
     [1, 0, 0, 0],
     [0, 1, 0, 0],
@@ -42,19 +49,19 @@ ATCGAATCGA
 ATCGAATCGA`;
 
   test('protein-distance-function', async () => {
-    const sh = await _initMacromoleculeColumn(protTable);
+    const sh = await _initMacromoleculeColumn(protTable, seqHelper);
     const distFunc = sh.getDistanceFunctionName();
     expect(distFunc, MmDistanceFunctionsNames.LEVENSHTEIN);
   });
 
   test('DNA-distance-function', async () => {
-    const sh = await _initMacromoleculeColumn(DNATable);
+    const sh = await _initMacromoleculeColumn(DNATable, seqHelper);
     const distFunc = sh.getDistanceFunctionName();
     expect(distFunc, MmDistanceFunctionsNames.LEVENSHTEIN);
   });
 
   test('MSA-distance-function', async () => {
-    const sh = await _initMacromoleculeColumn(MSATable);
+    const sh = await _initMacromoleculeColumn(MSATable, seqHelper);
     const distFunc = sh.getDistanceFunctionName();
     expect(distFunc, MmDistanceFunctionsNames.HAMMING);
   });
@@ -127,7 +134,7 @@ ATCGAATCGA`;
   }, {benchmark: true});
 });
 
-async function _initMacromoleculeColumn(csv: string): Promise<SeqHandler> {
+async function _initMacromoleculeColumn(csv: string, seqHelper: ISeqHelper): Promise<ISeqHandler> {
   const srcDf: DG.DataFrame = DG.DataFrame.fromCsv(csv);
   const seqCol = srcDf.col('seq')!;
   const semType: string = await grok.functions
@@ -135,7 +142,7 @@ async function _initMacromoleculeColumn(csv: string): Promise<SeqHandler> {
   if (semType)
     seqCol.semType = semType;
   await grok.data.detectSemanticTypes(srcDf);
-  const sh = SeqHandler.forColumn(seqCol);
+  const sh = seqHelper.getSeqHandler(seqCol);
   return sh;
 }
 

package/src/tests/monomer-libraries-tests.ts

@@ -83,7 +83,7 @@ category('monomerLibraries', () => {
     const absentOverrideMonomer = monomerLib.getMonomer(overMon.polymerType, overMon.symbol);
     expect(absentOverrideMonomer === null, true, `Unexpectedly found monomer '${overMon.symbol}' `);
 
-    const overriddenMonomerLib = monomerLib.override({[overMon.polymerType]: {[overMon.symbol]: overMon}});
+    const overriddenMonomerLib = monomerLib.override({[overMon.polymerType]: {[overMon.symbol]: overMon}}, 'test');
     const resOverMon = overriddenMonomerLib.getMonomer(overMon.polymerType, overMon.symbol);
     expectObject(resOverMon as any, overMon);
   });

package/src/tests/msa-tests.ts

@@ -2,13 +2,21 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+
 import {runKalign} from '../utils/multiple-sequence-alignment';
 import {multipleSequenceAlignmentUI} from '../utils/multiple-sequence-alignment-ui';
 import {awaitContainerStart} from '../utils/docker';
 
 category('MSA', async () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   //table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');
   const fromCsv = `seq
 FWRWYVKHP
@@ -99,6 +107,30 @@ MWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHP
       SeparatorLongFromCsv, SeparatorLongToCsv, NOTATION.SEPARATOR, NOTATION.FASTA, ALPHABET.PT,
     );
   });
+
+  async function _testMSAOnColumn(
+    srcCsv: string, tgtCsv: string,
+    srcNotation: NOTATION, tgtNotation: NOTATION, alphabet?: ALPHABET, pepseaMethod?: string,
+  ): Promise<void> {
+    const srcDf: DG.DataFrame = DG.DataFrame.fromCsv(srcCsv);
+    await grok.data.detectSemanticTypes(srcDf);
+    const tgtDf: DG.DataFrame = DG.DataFrame.fromCsv(tgtCsv);
+
+    const tgtCol = tgtDf.getCol('seq')!;
+    const srcCol: DG.Column = srcDf.getCol('seq')!;
+    expect(srcCol.semType, DG.SEMTYPE.MACROMOLECULE);
+    expect(srcCol.meta.units, srcNotation);
+    if (alphabet)
+      expect(srcCol.getTag(bioTAGS.alphabet), alphabet);
+
+    const msaSeqCol = await multipleSequenceAlignmentUI({col: srcCol, pepsea: {method: pepseaMethod}}, seqHelper);
+    expect(msaSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
+    expect(msaSeqCol.meta.units, tgtNotation);
+    expect(msaSeqCol.getTag(bioTAGS.aligned), ALIGNMENT.SEQ_MSA);
+    if (alphabet)
+      expect(msaSeqCol.getTag(bioTAGS.alphabet), alphabet);
+    expectArray(msaSeqCol.toList(), tgtCol.toList());
+  }
 });
 
 async function _testMsaIsCorrect(srcCsv: string, tgtCsv: string): Promise<void> {
@@ -114,27 +146,4 @@ async function _testMsaIsCorrect(srcCsv: string, tgtCsv: string): Promise<void>
   expectArray(resCol.toList(), tgtCol.toList());
 }
 
-async function _testMSAOnColumn(
-  srcCsv: string, tgtCsv: string,
-  srcNotation: NOTATION, tgtNotation: NOTATION, alphabet?: ALPHABET, pepseaMethod?: string,
-): Promise<void> {
-  const srcDf: DG.DataFrame = DG.DataFrame.fromCsv(srcCsv);
-  await grok.data.detectSemanticTypes(srcDf);
-  const tgtDf: DG.DataFrame = DG.DataFrame.fromCsv(tgtCsv);
 
-  const tgtCol = tgtDf.getCol('seq')!;
-  const srcCol: DG.Column = srcDf.getCol('seq')!;
-  expect(srcCol.semType, DG.SEMTYPE.MACROMOLECULE);
-  expect(srcCol.meta.units, srcNotation);
-  if (alphabet)
-    expect(srcCol.getTag(bioTAGS.alphabet), alphabet);
-
-  const msaSeqCol = await multipleSequenceAlignmentUI({col: srcCol, pepsea: {method: pepseaMethod}});
-  expect(msaSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
-  expect(msaSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
-  expect(msaSeqCol.meta.units, tgtNotation);
-  expect(msaSeqCol.getTag(bioTAGS.aligned), ALIGNMENT.SEQ_MSA);
-  if (alphabet)
-    expect(msaSeqCol.getTag(bioTAGS.alphabet), alphabet);
-  expectArray(msaSeqCol.toList(), tgtCol.toList());
-}

package/src/tests/renderers-monomer-placer-tests.ts

@@ -7,7 +7,7 @@ import wu from 'wu';
 import {after, before, category, expect, test} from '@datagrok-libraries/utils/src/test';
 import {MonomerPlacer, hitBounds} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
 import {monomerToShort} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
   getUserLibSettings, setUserLibSettings
@@ -115,14 +115,13 @@ id3,QHIRE--LT
       const sepWidth: number = 12;
       const colTemp: MonomerPlacer = new MonomerPlacer(null, seqCol, _package.logger, monLength,
         () => {
-          const sh = SeqHandler.forColumn(seqCol);
           return {
-            seqHandler: sh,
             monomerCharWidth: charWidth,
             separatorWidth: sepWidth,
             monomerToShort: monomerToShort,
           };
         });
+      await colTemp.init();
 
       const width: number = 10000;
       const testList = testData.testList;
@@ -142,9 +141,7 @@ id3,QHIRE--LT
         throw new Error('Test failed error(s):\n' + errorList.join(', \n'));
     });
   }
-});
 
-category('renderers: monomerPlacer', () => {
   const boundsTestData = {
     bounds: [10, 20, 30, 40, 50, 60],
     tests: {