@datagrok/bio 2.15.13 → 2.16.2

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: {

package/src/tests/renderers-test.ts

@@ -5,12 +5,12 @@ import * as ui from 'datagrok-api/ui';
 import $ from 'cash-dom';
 import {fromEvent} from 'rxjs';
 
-import {category, expect, test, delay, testEvent} from '@datagrok-libraries/utils/src/test';
+import {category, expect, test, delay, testEvent, 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 {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
 import {generateLongSequence, generateManySequences} from '@datagrok-libraries/bio/src/utils/generator';
 
-import {importFasta} from '../package';
 import {convertDo} from '../utils/convert';
 import {performanceTest} from './utils/sequences-generators';
 import {multipleSequenceAlignmentUI} from '../utils/multiple-sequence-alignment-ui';
@@ -20,6 +20,12 @@ import * as C from '../utils/constants';
 import {_package} from '../package-test';
 
 category('renderers', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   test('long sequence performance ', async () => {
     await performanceTest(generateLongSequence, 'Long sequences');
   });
@@ -124,7 +130,7 @@ category('renderers', () => {
 
   async function _testAfterMsa() {
     const fastaTxt: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/FASTA.fasta');
-    const df: DG.DataFrame = importFasta(fastaTxt)[0];
+    const df = (await grok.functions.call('Bio:importFasta', {fileContent: fastaTxt}))[0] as DG.DataFrame;
 
     const srcSeqCol: DG.Column = df.getCol('sequence');
     const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: srcSeqCol});
@@ -148,7 +154,7 @@ category('renderers', () => {
     expect(srcSeqCol.getTag(bioTAGS.alphabet), ALPHABET.PT);
     expect(srcSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
-    const msaSeqCol = await multipleSequenceAlignmentUI({col: srcSeqCol});
+    const msaSeqCol = await multipleSequenceAlignmentUI({col: srcSeqCol}, seqHelper);
     await awaitGrid(tv.grid);
     expect(tv.grid.dataFrame.id, df.id);
 
@@ -159,7 +165,7 @@ category('renderers', () => {
     expect(msaSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
     // check newColumn with SeqHandler constructor
-    const _sh: SeqHandler = SeqHandler.forColumn(msaSeqCol);
+    const _sh: ISeqHandler = seqHelper.getSeqHandler(msaSeqCol);
   }
 
   async function _testAfterConvert() {
@@ -175,7 +181,7 @@ category('renderers', () => {
     // call to calculate 'cell.renderer' tag
     await grok.data.detectSemanticTypes(df);
 
-    const tgtCol: DG.Column = await convertDo(srcCol, NOTATION.SEPARATOR, '/');
+    const tgtCol: DG.Column = await convertDo(srcCol, seqHelper, NOTATION.SEPARATOR, '/');
     await awaitGrid(tv.grid);
     expect(tv.grid.dataFrame.id, df.id);
 
@@ -183,7 +189,7 @@ category('renderers', () => {
     expect(resCellRenderer, 'sequence');
 
     // check tgtCol with SeqHandler constructor
-    const _sh: SeqHandler = SeqHandler.forColumn(tgtCol);
+    const _sh: ISeqHandler = seqHelper.getSeqHandler(tgtCol);
   }
 
   async function _testAfterConvertToHelm() {
@@ -192,7 +198,7 @@ category('renderers', () => {
     await awaitGrid(view.grid);
 
     const srcCol = df.getCol('sequence');
-    const sh = SeqHandler.forColumn(srcCol);
+    const sh = seqHelper.getSeqHandler(srcCol);
     const tgtCol = sh.convert(NOTATION.HELM);
     df.columns.add(tgtCol);
     await awaitGrid(view.grid);

package/src/tests/scoring.ts

@@ -6,9 +6,8 @@ import wu from 'wu';
 
 import {category, test, expectFloat, before, after, expect} from '@datagrok-libraries/utils/src/test';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {IMonomerLibHelper, getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
-import {getMonomerLibHelper, sequenceIdentityScoring, sequenceSimilarityScoring} from '../package';
 import {
   getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
@@ -51,7 +50,8 @@ PEPTIDE1{[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[
   });
 
   test('Identity', async () => {
-    const scoresCol = await sequenceIdentityScoring(table, seqCol, reference);
+    const scoresCol = await grok.functions.call('Bio:sequenceIdentityScoring',
+      {table: table, macromolecule: seqCol, reference: reference}) as DG.Column<number>;
     for (let i = 0; i < scoresCol.length; i++) {
       const resScore = scoresCol.get(i)!;
       const tgtScore = table.get(expectedIdentity, i);
@@ -61,19 +61,22 @@ PEPTIDE1{[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[
   });
 
   test('Identity-shortReference', async () => {
-    const scoresCol = await sequenceIdentityScoring(table, seqCol, shortReference);
+    const scoresCol = await grok.functions.call('Bio:sequenceIdentityScoring',
+      {table: table, macromolecule: seqCol, reference: shortReference}) as DG.Column<number>;
     expect(wu.count(0).take(scoresCol.length).map((rowI) => scoresCol.get(rowI))
       .every((v) => v != null && !isNaN(v)), true);
   });
 
   test('Identity-longReference', async () => {
-    const scoresCol = await sequenceIdentityScoring(table, seqCol, longReference);
+    const scoresCol = await grok.functions.call('Bio:sequenceIdentityScoring',
+      {table: table, macromolecule: seqCol, reference: longReference}) as DG.Column<number>;
     expect(wu.count(0).take(scoresCol.length).map((rowI) => scoresCol.get(rowI))
       .every((v) => v != null && !isNaN(v)), true);
   });
 
   test('Similarity', async () => {
-    const scoresCol = await sequenceSimilarityScoring(table, seqCol, reference);
+    const scoresCol = await grok.functions.call('Bio:sequenceSimilarityScoring',
+      {table: table, macromolecule: seqCol, reference: reference}) as DG.Column<number>;
     for (let i = 0; i < scoresCol.length; i++) {
       const resScore = scoresCol.get(i)!;
       const tgtScore = table.get(expectedSimilarity, i);

package/src/tests/seq-handler-get-helm-tests.ts

@@ -3,17 +3,19 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {after, before, category, expect, test} from '@datagrok-libraries/utils/src/test';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
-import {NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
 category('SeqHandler: getHelm', () => {
+  let seqHelper: ISeqHelper;
   let monomerLibHelper: IMonomerLibHelper;
   let userLibSettings: UserLibSettings; // backup
 
   before(async () => {
+    seqHelper = await getSeqHelper();
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
 
@@ -26,7 +28,6 @@ category('SeqHandler: getHelm', () => {
     await monomerLibHelper.loadMonomerLib(true); // load user settings libraries
   });
 
-
   const tests: {
     [testName: string]: {
       src: {
@@ -79,8 +80,9 @@ category('SeqHandler: getHelm', () => {
     // if (srcSeparator) seqCol.setTag(TAGS.separator, srcSeparator);
     await grok.data.detectSemanticTypes(df);
 
-    const sh = SeqHandler.forColumn(seqCol);
-    const resHelm = await sh.getHelm(0, false);
+    const sh = seqHelper.getSeqHandler(seqCol);
+    const resSemValue = await sh.getHelm(0);
+    const resHelm = resSemValue.value;
     expect(resHelm, tgtHelm);
   }
 });

package/src/tests/seq-handler-get-region-tests.ts

@@ -1,11 +1,17 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {ALPHABET, NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 category('SeqHandler: getRegion', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   const data: {
     [testName: string]: {
       srcCsv: string,
@@ -76,7 +82,7 @@ PEPTIDE1{[Cys_SEt].T.*.*}$$$$`,
       const semType: string | null = await grok.functions.call('Bio:detectMacromolecule', {col: srcSeqCol});
       if (semType) srcSeqCol.semType = semType;
 
-      const srcSh = SeqHandler.forColumn(srcSeqCol);
+      const srcSh = seqHelper.getSeqHandler(srcSeqCol);
       const resSeqCol = srcSh.getRegion(testData.startIdx, testData.endIdx, 'regSeq');
 
       const tgtDf = DG.DataFrame.fromCsv(testData.tgtCsv);

package/src/tests/seq-handler-splitted-tests.ts

@@ -3,8 +3,8 @@ import * as DG from 'datagrok-api/dg';
 
 import wu from 'wu';
 
-import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {GapOriginals} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
@@ -16,7 +16,13 @@ enum Tests {
   helm = 'helm',
 }
 
-category('SeqHandler', () => {
+category('SeqHandler: splitted', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   const fG = GapOriginals[NOTATION.FASTA];
   const hG = GapOriginals[NOTATION.HELM];
   const sG = GapOriginals[NOTATION.SEPARATOR];
@@ -123,7 +129,7 @@ PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.T.dK.Thr_PO3H2}$$$$`
   };
 
   for (const [testName, testData] of Object.entries(data)) {
-    test(`splitted-${testName}`, async () => {
+    test(`${testName}`, async () => {
       const df: DG.DataFrame = DG.DataFrame.fromCsv(testData.src.csv);
       const col: DG.Column = df.getCol('seq');
 
@@ -131,7 +137,7 @@ PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.T.dK.Thr_PO3H2}$$$$`
       if (semType) col.semType = semType;
       expect(col.semType, DG.SEMTYPE.MACROMOLECULE);
 
-      const sh = SeqHandler.forColumn(col);
+      const sh = seqHelper.getSeqHandler(col);
       expect(sh.notation, testData.tgt.notation);
       expect(sh.separator === testData.tgt.separator, true);
 

package/src/tests/seq-handler-tests.ts

@@ -2,9 +2,10 @@ 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 {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {category, test, expect, before} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
 
 const seqDna = `seq
 ACGTCACGTC
@@ -28,6 +29,12 @@ PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Thr_PO3H
 PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Thr_PO3H2.N.D-Orn.D-aThr.Phe_4Me}$$$$`;
 
 category('SeqHandler', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   test('Seq-Fasta', async () => {
     const [_df, sh] = await loadCsvWithDetection(seqDna);
     expect(sh.notation, NOTATION.FASTA);
@@ -78,38 +85,38 @@ category('SeqHandler', () => {
     const seqCol = df.getCol('seq');
 
     // col.version will change because of changing .tags
-    const sh1 = SeqHandler.forColumn(seqCol);
+    const sh1 = seqHelper.getSeqHandler(seqCol);
 
     const v1 = seqCol.version;
     // col.version MUST NOT change and the same object returned
-    const sh2 = SeqHandler.forColumn(seqCol);
+    const sh2 = seqHelper.getSeqHandler(seqCol);
     const v2 = seqCol.version;
     expect(v1, v2, 'Unexpected column version changed');
     expect(sh1, sh2, 'Unexpected SeqHandler object changed');
 
     df.rows.addNew(['TACCCCTTCAAC']);
-    const sh3 = SeqHandler.forColumn(seqCol);
+    const sh3 = seqHelper.getSeqHandler(seqCol);
     const v3 = seqCol.version;
     expect(v2 < v3, true, 'Stalled column version on add row');
     expect(sh2 !== sh3, true, 'Stalled SeqHandler object on add row');
 
     seqCol.set(1, 'CAGTGTCCCCGT');
-    const sh4 = SeqHandler.forColumn(seqCol);
+    const sh4 = seqHelper.getSeqHandler(seqCol);
     const v4 = seqCol.version;
     expect(v3 < v4, true, 'Stalled column version on change data');
     expect(sh3 !== sh4, true, 'Stalled SeqHandler object on change data');
 
     seqCol.setTag('testTag', 'testValue');
-    const sh5 = SeqHandler.forColumn(seqCol);
+    const sh5 = seqHelper.getSeqHandler(seqCol);
     const v5 = seqCol.version;
     expect(v4 < v5, true, 'Stalled column version on set tag');
     expect(sh4 !== sh5, true, 'Stalled SeqHandler object on set tag');
   });
 
-  async function loadCsvWithDetection(csv: string): Promise<[df: DG.DataFrame, sh: SeqHandler]> {
+  async function loadCsvWithDetection(csv: string): Promise<[df: DG.DataFrame, sh: ISeqHandler]> {
     const df = DG.DataFrame.fromCsv(csv);
     await grok.data.detectSemanticTypes(df);
-    const sh = SeqHandler.forColumn(df.getCol('seq'));
+    const sh = seqHelper.getSeqHandler(df.getCol('seq'));
     return [df, sh];
   }
 
@@ -121,7 +128,7 @@ category('SeqHandler', () => {
   //   col.semType = DG.SEMTYPE.MACROMOLECULE;
   //   if (value === NOTATION.SEPARATOR)
   //     col.setTag(TAGS.separator, '-');
-  //   const sh = SeqHandler.forColumn(df.getCol('seq'));
+  //   const sh = seqHelper.getSeqHandler(df.getCol('seq'));
   //   return [df, sh];
   // }
 });