@datagrok/bio 2.15.13 → 2.16.2

package/src/tests/bio-tests.ts

@@ -2,7 +2,7 @@ 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, expectObject, expectArray} from '@datagrok-libraries/utils/src/test';
+import {category, test, expect, expectObject, expectArray, before} from '@datagrok-libraries/utils/src/test';
 import {
   NOTATION, getAlphabetSimilarity, monomerToShort, pickUpPalette, splitterAsFasta, splitterAsHelm,
 } from '@datagrok-libraries/bio/src/utils/macromolecule';
@@ -11,11 +11,18 @@ import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
 import {UnknownSeqPalette} from '@datagrok-libraries/bio/src/unknown';
 import {getStatsForCol} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
 import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 /** GAP_SYMBOL */
 const g: string = GAP_SYMBOL;
 
 category('bio', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   const csvDfN1: string = `seq
 ACGTCT
 CAGTGT
@@ -74,6 +81,83 @@ PEPTIDE1{meI}$$$$`;
   test('testPickupPaletteN1e', async () => { await _testPickupPaletteN1e(csvDfN1e); });
   test('testPickupPaletteAA1', async () => { await _testPickupPaletteAA1(csvDfAA1); });
   test('testPickupPaletteX', async () => { await _testPickupPaletteX(csvDfX); });
+
+  function _testGetStats(csvDfN1: string) {
+    const dfN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
+    const seqCol: DG.Column = dfN1.col('seq')!;
+    seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    seqCol.meta.units = NOTATION.FASTA;
+    const stats = getStatsForCol(seqCol, 5, splitterAsFasta);
+
+    expectObject(stats.freq, {
+      'A': 4,
+      'C': 5,
+      'G': 3,
+      'T': 6,
+    });
+    expect(stats.sameLength, true);
+  }
+
+  async function _testGetAlphabetSimilarity() {
+    const freq: { [m: string]: number } = {
+      'A': 2041,
+      'C': 3015,
+      'G': 3015,
+      'T': 2048,
+      [g]: 1000,
+    };
+    const alphabet: Set<string> = new Set(Object.keys(Nucleotides.Names));
+    const res = getAlphabetSimilarity(freq, alphabet);
+
+    expect(res > 0.6, true);
+  }
+
+  async function _testPickupPaletteN1(csvDfN1: string) {
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
+    const col: DG.Column = df.col('seq')!;
+    col.semType = DG.SEMTYPE.MACROMOLECULE;
+    col.meta.units = NOTATION.FASTA;
+    const cp = pickUpPalette(col, seqHelper);
+
+    expect(cp instanceof NucleotidesPalettes, true);
+  }
+
+  async function _testPickupPaletteN1e(csvDfN1e: string) {
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1e);
+    const col: DG.Column = df.col('seq')!;
+    col.semType = DG.SEMTYPE.MACROMOLECULE;
+    col.meta.units = NOTATION.FASTA;
+    const cp = pickUpPalette(col, seqHelper);
+
+    expect(cp instanceof NucleotidesPalettes, true);
+  }
+
+  async function _testPickupPaletteAA1(csvDfAA1: string) {
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfAA1);
+    const col: DG.Column = df.col('seq')!;
+    col.semType = DG.SEMTYPE.MACROMOLECULE;
+    col.meta.units = NOTATION.FASTA;
+    const cp = pickUpPalette(col, seqHelper);
+
+    expect(cp instanceof AminoacidsPalettes, true);
+  }
+
+  async function _testPickupPaletteX(csvDfX: string) {
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfX);
+    const col: DG.Column = df.col('seq')!;
+    col.semType = DG.SEMTYPE.MACROMOLECULE;
+    col.meta.units = NOTATION.FASTA;
+    const cp = pickUpPalette(col, seqHelper);
+
+    expect(cp instanceof UnknownSeqPalette, true);
+  }
+
+  async function _testPickupPaletteAA2(dfAA2: DG.DataFrame) {
+    const seqCol: DG.Column = dfAA2.col('seq')!;
+    const cp = pickUpPalette(seqCol, seqHelper);
+
+    expect(cp instanceof AminoacidsPalettes, true);
+  }
 });
 
 category('WebLogo.monomerToShort', () => {
@@ -123,81 +207,3 @@ category('WebLogo.monomerToShort', () => {
     expectArray(res, tgt);
   });
 });
-
-
-export async function _testGetStats(csvDfN1: string) {
-  const dfN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
-  const seqCol: DG.Column = dfN1.col('seq')!;
-  seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
-  seqCol.meta.units = NOTATION.FASTA;
-  const stats = getStatsForCol(seqCol, 5, splitterAsFasta);
-
-  expectObject(stats.freq, {
-    'A': 4,
-    'C': 5,
-    'G': 3,
-    'T': 6,
-  });
-  expect(stats.sameLength, true);
-}
-
-export async function _testGetAlphabetSimilarity() {
-  const freq: { [m: string]: number } = {
-    'A': 2041,
-    'C': 3015,
-    'G': 3015,
-    'T': 2048,
-    [g]: 1000,
-  };
-  const alphabet: Set<string> = new Set(Object.keys(Nucleotides.Names));
-  const res = getAlphabetSimilarity(freq, alphabet);
-
-  expect(res > 0.6, true);
-}
-
-export async function _testPickupPaletteN1(csvDfN1: string) {
-  const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
-  const col: DG.Column = df.col('seq')!;
-  col.semType = DG.SEMTYPE.MACROMOLECULE;
-  col.meta.units = NOTATION.FASTA;
-  const cp = pickUpPalette(col);
-
-  expect(cp instanceof NucleotidesPalettes, true);
-}
-
-export async function _testPickupPaletteN1e(csvDfN1e: string) {
-  const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1e);
-  const col: DG.Column = df.col('seq')!;
-  col.semType = DG.SEMTYPE.MACROMOLECULE;
-  col.meta.units = NOTATION.FASTA;
-  const cp = pickUpPalette(col);
-
-  expect(cp instanceof NucleotidesPalettes, true);
-}
-
-export async function _testPickupPaletteAA1(csvDfAA1: string) {
-  const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfAA1);
-  const col: DG.Column = df.col('seq')!;
-  col.semType = DG.SEMTYPE.MACROMOLECULE;
-  col.meta.units = NOTATION.FASTA;
-  const cp = pickUpPalette(col);
-
-  expect(cp instanceof AminoacidsPalettes, true);
-}
-
-export async function _testPickupPaletteX(csvDfX: string) {
-  const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfX);
-  const col: DG.Column = df.col('seq')!;
-  col.semType = DG.SEMTYPE.MACROMOLECULE;
-  col.meta.units = NOTATION.FASTA;
-  const cp = pickUpPalette(col);
-
-  expect(cp instanceof UnknownSeqPalette, true);
-}
-
-export async function _testPickupPaletteAA2(dfAA2: DG.DataFrame) {
-  const seqCol: DG.Column = dfAA2.col('seq')!;
-  const cp = pickUpPalette(seqCol);
-
-  expect(cp instanceof AminoacidsPalettes, true);
-}

package/src/tests/checkInputColumn-tests.ts

@@ -2,12 +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, expect} from '@datagrok-libraries/utils/src/test';
+import {category, test, expect, before} from '@datagrok-libraries/utils/src/test';
 
 import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+
 import {checkInputColumn} from '../utils/check-input-column';
 
 category('checkInputColumn', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   const csv = `seq
 seq1,
 seq2,
@@ -22,9 +30,8 @@ seq4`;
     col.setTag(bioTAGS.alphabet, ALPHABET.DNA);
     col.setTag(bioTAGS.aligned, 'SEQ');
 
-    const [res, _msg]: [boolean, string] = checkInputColumn(
-      col, 'Test', [NOTATION.FASTA],
-      [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT]);
+    const [res, _msg]: [boolean, string] = checkInputColumn(col, 'Test', seqHelper,
+      [NOTATION.FASTA], [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT]);
 
     expect(res, true);
   });
@@ -37,9 +44,8 @@ seq4`;
     // col.setTag(bio.TAGS.alphabetSize, '11');
     col.setTag(bioTAGS.alphabetIsMultichar, 'true');
 
-    const [res, _msg]: [boolean, string] = checkInputColumn(
-      col, 'Test', [NOTATION.FASTA],
-      [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT]);
+    const [res, _msg]: [boolean, string] = checkInputColumn(col, 'Test', seqHelper,
+      [NOTATION.FASTA], [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT]);
 
     expect(res, false);
   });
@@ -54,9 +60,8 @@ seq4`;
     col.setTag(bioTAGS.alphabetIsMultichar, 'true');
     col.setTag(bioTAGS.aligned, 'SEQ');
 
-    const [res, _msg]: [boolean, string] = checkInputColumn(
-      col, 'Test', [NOTATION.FASTA],
-      [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT]);
+    const [res, _msg]: [boolean, string] = checkInputColumn(col, 'Test', seqHelper,
+      [NOTATION.FASTA], [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT]);
 
     expect(res, false);
   });

package/src/tests/converters-test.ts

@@ -1,14 +1,21 @@
 import * as DG from 'datagrok-api/dg';
 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, 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 {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
 
 import {ConverterFunc} from './types';
 
 
 category('converters', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   enum Samples {
     fastaPt = 'fastaPt',
     separatorPt = 'separatorPt',
@@ -133,7 +140,7 @@ RNA1{p.r(U)p.r(U)p.r(C)p.r(A)p.r(A)p.r(C)p.r(U)p.r(U)p.r(C)p.r(A)p.r(A)p.r(C)p.p
       throw new Error(`Argument 'separator' is mandatory for target notation '${tgtNotation.toString()}'.`);
 
     return function(srcCol: DG.Column): DG.Column {
-      const converterSh = SeqHandler.forColumn(srcCol);
+      const converterSh = seqHelper.getSeqHandler(srcCol);
       const resCol = converterSh.convert(tgtNotation, tgtSeparator);
       expect(resCol.meta.units, tgtNotation);
       return resCol;
@@ -152,8 +159,8 @@ RNA1{p.r(U)p.r(U)p.r(C)p.r(A)p.r(A)p.r(C)p.r(U)p.r(U)p.r(C)p.r(A)p.r(A)p.r(C)p.p
     const tgtCol: DG.Column = tgtDf.getCol('seq');
 
     expectArray(resCol.toList(), tgtCol.toList());
-    const srcSh: SeqHandler = SeqHandler.forColumn(srcCol);
-    const resSh: SeqHandler = SeqHandler.forColumn(resCol);
+    const srcSh: ISeqHandler = seqHelper.getSeqHandler(srcCol);
+    const resSh: ISeqHandler = seqHelper.getSeqHandler(resCol);
     for (const [tagName, tgtTagValue] of Object.entries(tgtCol.tags)) {
       if (
         !bioTagsSet.has(tagName) ||

package/src/tests/detectors-benchmark-tests.ts

@@ -4,14 +4,17 @@ import * as DG from 'datagrok-api/dg';
 
 import {before, category, test, expect} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, getAlphabet, NOTATION} 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 {_package} from '../package-test';
 
+
 category('detectorsBenchmark', () => {
+  let seqHelper: ISeqHelper;
   let detectFunc: DG.Func;
 
   before(async () => {
+    seqHelper = await getSeqHelper();
     const funcList: DG.Func[] = DG.Func.find({package: 'Bio', name: 'detectMacromolecule'});
     detectFunc = funcList[0];
 
@@ -125,7 +128,7 @@ category('detectorsBenchmark', () => {
   }
 
   function checkDetectorRes(col: DG.Column, tgt: TgtType): void {
-    const sh = SeqHandler.forColumn(col);
+    const sh = seqHelper.getSeqHandler(col);
     expect(col.semType === tgt.semType, true);
     expect(sh.notation === tgt.notation, true);
     expect(sh.alphabet === tgt.alphabet, true);

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);
   });