@datagrok/bio 2.1.11 → 2.1.12

package/src/tests/bio-tests.ts

@@ -1,9 +1,20 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import * as bio from '@datagrok-libraries/bio';
 
 import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
+import {
+  AminoacidsPalettes,
+  getAlphabetSimilarity,
+  getStats,
+  monomerToShort,
+  Nucleotides,
+  NucleotidesPalettes,
+  pickUpPalette,
+  splitterAsFasta,
+  splitterAsHelm,
+  UnknownSeqPalette
+} from '@datagrok-libraries/bio';
 
 category('bio', () => {
   const csvDfN1: string = `seq
@@ -53,7 +64,7 @@ PEPTIDE1{meI}$$$$
 `;
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
     const seqCol: DG.Column = df.getCol('seq')!;
-    const stats = bio.getStats(seqCol, 1, bio.splitterAsHelm);
+    const stats = getStats(seqCol, 1, splitterAsHelm);
 
     expectObject(stats.freq, {
       'meI': 1
@@ -72,19 +83,19 @@ PEPTIDE1{meI}$$$$
 
 category('WebLogo.monomerToShort', () => {
   test('longMonomerSingle', async () => {
-    await expect(bio.monomerToShort('S', 5), 'S');
+    await expect(monomerToShort('S', 5), 'S');
   });
   test('longMonomerShort', async () => {
-    await expect(bio.monomerToShort('Short', 5), 'Short');
+    await expect(monomerToShort('Short', 5), 'Short');
   });
   test('longMonomerLong56', async () => {
-    await expect(bio.monomerToShort('Long56', 5), 'Long5…');
+    await expect(monomerToShort('Long56', 5), 'Long5…');
   });
   test('longMonomerComplexFirstPartShort', async () => {
-    await expect(bio.monomerToShort('Long-long', 5), 'Long…');
+    await expect(monomerToShort('Long-long', 5), 'Long…');
   });
   test('longMonomerComplexFirstPartLong56', async () => {
-    await expect(bio.monomerToShort('Long56-long', 5), 'Long5…');
+    await expect(monomerToShort('Long56-long', 5), 'Long5…');
   });
 });
 
@@ -92,7 +103,7 @@ category('WebLogo.monomerToShort', () => {
 export async function _testGetStats(csvDfN1: string) {
   const dfN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
   const seqCol: DG.Column = dfN1.col('seq')!;
-  const stats = bio.getStats(seqCol, 5, bio.splitterAsFasta);
+  const stats = getStats(seqCol, 5, splitterAsFasta);
 
   expectObject(stats.freq, {
     'A': 4,
@@ -111,8 +122,8 @@ export async function _testGetAlphabetSimilarity() {
     'T': 2048,
     '-': 1000
   };
-  const alphabet: Set<string> = new Set(Object.keys(bio.Nucleotides.Names));
-  const res = bio.getAlphabetSimilarity(freq, alphabet);
+  const alphabet: Set<string> = new Set(Object.keys(Nucleotides.Names));
+  const res = getAlphabetSimilarity(freq, alphabet);
 
   expect(res > 0.6, true);
 }
@@ -120,39 +131,38 @@ export async function _testGetAlphabetSimilarity() {
 export async function _testPickupPaletteN1(csvDfN1: string) {
   const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
   const col: DG.Column = df.col('seq')!;
-  const cp = bio.pickUpPalette(col);
+  const cp = pickUpPalette(col);
 
-  expect(cp instanceof bio.NucleotidesPalettes, true);
+  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')!;
-  const cp = bio.pickUpPalette(col);
+  const cp = pickUpPalette(col);
 
-  expect(cp instanceof bio.NucleotidesPalettes, true);
+  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')!;
-  const cp = bio.pickUpPalette(col);
+  const cp = pickUpPalette(col);
 
-  expect(cp instanceof bio.AminoacidsPalettes, true);
+  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')!;
-  const cp = bio.pickUpPalette(col);
+  const cp = pickUpPalette(col);
 
-  expect(cp instanceof bio.UnknownSeqPalette, true);
+  expect(cp instanceof UnknownSeqPalette, true);
 }
 
 export async function _testPickupPaletteAA2(dfAA2: DG.DataFrame) {
   const seqCol: DG.Column = dfAA2.col('seq')!;
-  const cp = bio.pickUpPalette(seqCol);
+  const cp = pickUpPalette(seqCol);
 
-  expect(cp instanceof bio.AminoacidsPalettes, true);
+  expect(cp instanceof AminoacidsPalettes, true);
 }
-

package/src/tests/checkInputColumn-tests.ts

@@ -1,12 +1,12 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import * as bio from '@datagrok-libraries/bio';
 
 
 import {after, before, category, test, expect, expectArray} from '@datagrok-libraries/utils/src/test';
 
 import {checkInputColumn, multipleSequenceAlignmentAny} from '../package';
+import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio';
 
 category('checkInputColumn', () => {
   const csv = `seq
@@ -24,13 +24,13 @@ seq4`;
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
     const col: DG.Column = df.getCol('seq');
     col.semType = DG.SEMTYPE.MACROMOLECULE;
-    col.setTag(DG.TAGS.UNITS, bio.NOTATION.FASTA);
-    col.setTag(bio.TAGS.alphabet, bio.ALPHABET.DNA);
-    col.setTag(bio.TAGS.aligned, 'SEQ');
+    col.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    col.setTag(bioTAGS.alphabet, ALPHABET.DNA);
+    col.setTag(bioTAGS.aligned, 'SEQ');
 
     const [res, msg]: [boolean, string] = checkInputColumn(
-      col, 'Test', [bio.NOTATION.FASTA,],
-      [bio.ALPHABET.DNA, bio.ALPHABET.RNA, bio.ALPHABET.PT]);
+      col, 'Test', [NOTATION.FASTA],
+      [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT]);
 
     expect(res, true);
   });
@@ -39,13 +39,13 @@ seq4`;
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
     const col: DG.Column = df.getCol('seq');
     col.semType = DG.SEMTYPE.MACROMOLECULE;
-    col.setTag(DG.TAGS.UNITS, bio.NOTATION.HELM);
+    col.setTag(DG.TAGS.UNITS, NOTATION.HELM);
     // col.setTag(bio.TAGS.alphabetSize, '11');
-    col.setTag(bio.TAGS.alphabetIsMultichar, 'true');
+    col.setTag(bioTAGS.alphabetIsMultichar, 'true');
 
     const [res, msg]: [boolean, string] = checkInputColumn(
-      col, 'Test', [bio.NOTATION.FASTA,],
-      [bio.ALPHABET.DNA, bio.ALPHABET.RNA, bio.ALPHABET.PT]);
+      col, 'Test', [NOTATION.FASTA],
+      [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT]);
 
     expect(res, false);
   });
@@ -54,15 +54,15 @@ seq4`;
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
     const col: DG.Column = df.getCol('seq');
     col.semType = DG.SEMTYPE.MACROMOLECULE;
-    col.setTag(DG.TAGS.UNITS, bio.NOTATION.FASTA);
-    col.setTag(bio.TAGS.alphabet, 'UN');
-    col.setTag(bio.TAGS.alphabetSize, '11');
-    col.setTag(bio.TAGS.alphabetIsMultichar, 'true');
-    col.setTag(bio.TAGS.aligned, 'SEQ');
+    col.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    col.setTag(bioTAGS.alphabet, 'UN');
+    col.setTag(bioTAGS.alphabetSize, '11');
+    col.setTag(bioTAGS.alphabetIsMultichar, 'true');
+    col.setTag(bioTAGS.aligned, 'SEQ');
 
     const [res, msg]: [boolean, string] = checkInputColumn(
-      col, 'Test', [bio.NOTATION.FASTA,],
-      [bio.ALPHABET.DNA, bio.ALPHABET.RNA, bio.ALPHABET.PT]);
+      col, 'Test', [NOTATION.FASTA],
+      [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT]);
 
     expect(res, false);
   });

package/src/tests/converters-test.ts

@@ -1,11 +1,11 @@
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
-import * as bio from '@datagrok-libraries/bio';
 
 import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
 
 import {ConverterFunc} from './types';
+import {NOTATION, NotationConverter, UnitsHandler} from '@datagrok-libraries/bio';
 
 // import {mmSemType} from '../const';
 // import {importFasta} from '../package';
@@ -132,12 +132,12 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
     return _csvDfs[key];
   };
 
-  function converter(tgtNotation: bio.NOTATION, tgtSeparator: string | null = null): ConverterFunc {
-    if (tgtNotation === bio.NOTATION.SEPARATOR && !tgtSeparator)
+  function converter(tgtNotation: NOTATION, tgtSeparator: string | null = null): ConverterFunc {
+    if (tgtNotation === NOTATION.SEPARATOR && !tgtSeparator)
       throw new Error(`Argument 'separator' is missed for notation '${tgtNotation.toString()}'.`);
 
     return function(srcCol: DG.Column): DG.Column {
-      const converter = new bio.NotationConverter(srcCol);
+      const converter = new NotationConverter(srcCol);
       const resCol = converter.convert(tgtNotation, tgtSeparator);
       expect(resCol.getTag('units'), tgtNotation);
       return resCol;
@@ -156,100 +156,100 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
     const tgtCol: DG.Column = tgtDf.getCol('seq');
 
     expectArray(resCol.toList(), tgtCol.toList());
-    const uh: bio.UnitsHandler = new bio.UnitsHandler(resCol);
+    const uh: UnitsHandler = new UnitsHandler(resCol);
   }
 
   // FASTA tests
   // fasta -> separator
   test('testFastaPtToSeparator', async () => {
-    await _testConvert(Samples.fastaPt, converter(bio.NOTATION.SEPARATOR, '-'), Samples.separatorPt);
+    await _testConvert(Samples.fastaPt, converter(NOTATION.SEPARATOR, '-'), Samples.separatorPt);
   });
   test('testFastaDnaToSeparator', async () => {
-    await _testConvert(Samples.fastaDna, converter(bio.NOTATION.SEPARATOR, '/'), Samples.separatorDna);
+    await _testConvert(Samples.fastaDna, converter(NOTATION.SEPARATOR, '/'), Samples.separatorDna);
   });
   test('testFastaRnaToSeparator', async () => {
-    await _testConvert(Samples.fastaRna, converter(bio.NOTATION.SEPARATOR, '*'), Samples.separatorRna);
+    await _testConvert(Samples.fastaRna, converter(NOTATION.SEPARATOR, '*'), Samples.separatorRna);
   });
   test('testFastaGapsToSeparator', async () => {
-    await _testConvert(Samples.fastaGaps, converter(bio.NOTATION.SEPARATOR, '/'), Samples.separatorGaps);
+    await _testConvert(Samples.fastaGaps, converter(NOTATION.SEPARATOR, '/'), Samples.separatorGaps);
   });
 
   // fasta -> helm
   test('testFastaPtToHelm', async () => {
-    await _testConvert(Samples.fastaPt, converter(bio.NOTATION.HELM), Samples.helmPt);
+    await _testConvert(Samples.fastaPt, converter(NOTATION.HELM), Samples.helmPt);
   });
   test('testFastaDnaToHelm', async () => {
-    await _testConvert(Samples.fastaDna, converter(bio.NOTATION.HELM), Samples.helmDna);
+    await _testConvert(Samples.fastaDna, converter(NOTATION.HELM), Samples.helmDna);
   });
   test('testFastaRnaToHelm', async () => {
-    await _testConvert(Samples.fastaRna, converter(bio.NOTATION.HELM), Samples.helmRna);
+    await _testConvert(Samples.fastaRna, converter(NOTATION.HELM), Samples.helmRna);
   });
   test('testFastaGapsToHelm', async () => {
-    await _testConvert(Samples.fastaGaps, converter(bio.NOTATION.HELM), Samples.helmGaps);
+    await _testConvert(Samples.fastaGaps, converter(NOTATION.HELM), Samples.helmGaps);
   });
 
 
   // SEPARATOR tests
   // separator -> fasta
   test('testSeparatorPtToFasta', async () => {
-    await _testConvert(Samples.separatorPt, converter(bio.NOTATION.FASTA), Samples.fastaPt);
+    await _testConvert(Samples.separatorPt, converter(NOTATION.FASTA), Samples.fastaPt);
   });
   test('testSeparatorDnaToFasta', async () => {
-    await _testConvert(Samples.separatorDna, converter(bio.NOTATION.FASTA), Samples.fastaDna);
+    await _testConvert(Samples.separatorDna, converter(NOTATION.FASTA), Samples.fastaDna);
   });
   test('testSeparatorRnaToFasta', async () => {
-    await _testConvert(Samples.separatorRna, converter(bio.NOTATION.FASTA), Samples.fastaRna);
+    await _testConvert(Samples.separatorRna, converter(NOTATION.FASTA), Samples.fastaRna);
   });
   test('testSeparatorGapsToFasta', async () => {
-    await _testConvert(Samples.separatorGaps, converter(bio.NOTATION.FASTA), Samples.fastaGaps);
+    await _testConvert(Samples.separatorGaps, converter(NOTATION.FASTA), Samples.fastaGaps);
   });
 
   // separator -> helm
   test('testSeparatorPtToHelm', async () => {
-    await _testConvert(Samples.separatorPt, converter(bio.NOTATION.HELM), Samples.helmPt);
+    await _testConvert(Samples.separatorPt, converter(NOTATION.HELM), Samples.helmPt);
   });
   test('testSeparatorDnaToHelm', async () => {
-    await _testConvert(Samples.separatorDna, converter(bio.NOTATION.HELM), Samples.helmDna);
+    await _testConvert(Samples.separatorDna, converter(NOTATION.HELM), Samples.helmDna);
   });
   test('testSeparatorRnaToHelm', async () => {
-    await _testConvert(Samples.separatorRna, converter(bio.NOTATION.HELM), Samples.helmRna);
+    await _testConvert(Samples.separatorRna, converter(NOTATION.HELM), Samples.helmRna);
   });
   test('testSeparatorGapsToHelm', async () => {
-    await _testConvert(Samples.separatorGaps, converter(bio.NOTATION.HELM), Samples.helmGaps);
+    await _testConvert(Samples.separatorGaps, converter(NOTATION.HELM), Samples.helmGaps);
   });
 
 
   // HELM tests
   // helm -> fasta
   test('testHelmDnaToFasta', async () => {
-    await _testConvert(Samples.helmDna, converter(bio.NOTATION.FASTA), Samples.fastaDna);
+    await _testConvert(Samples.helmDna, converter(NOTATION.FASTA), Samples.fastaDna);
   });
   test('testHelmRnaToFasta', async () => {
-    await _testConvert(Samples.helmRna, converter(bio.NOTATION.FASTA), Samples.fastaRna);
+    await _testConvert(Samples.helmRna, converter(NOTATION.FASTA), Samples.fastaRna);
   });
   test('testHelmPtToFasta', async () => {
-    await _testConvert(Samples.helmPt, converter(bio.NOTATION.FASTA), Samples.fastaPt);
+    await _testConvert(Samples.helmPt, converter(NOTATION.FASTA), Samples.fastaPt);
   });
 
   // helm -> separator
   test('testHelmDnaToSeparator', async () => {
-    await _testConvert(Samples.helmDna, converter(bio.NOTATION.SEPARATOR, '/'), Samples.separatorDna);
+    await _testConvert(Samples.helmDna, converter(NOTATION.SEPARATOR, '/'), Samples.separatorDna);
   });
   test('testHelmRnaToSeparator', async () => {
-    await _testConvert(Samples.helmRna, converter(bio.NOTATION.SEPARATOR, '*'), Samples.separatorRna);
+    await _testConvert(Samples.helmRna, converter(NOTATION.SEPARATOR, '*'), Samples.separatorRna);
   });
   test('testHelmPtToSeparator', async () => {
-    await _testConvert(Samples.helmPt, converter(bio.NOTATION.SEPARATOR, '-'), Samples.separatorPt);
+    await _testConvert(Samples.helmPt, converter(NOTATION.SEPARATOR, '-'), Samples.separatorPt);
   });
 
   // helm miscellaneous
   test('testHelmLoneRibose', async () => {
-    await _testConvert(Samples.helmLoneRibose, converter(bio.NOTATION.FASTA), Samples.fastaRna);
+    await _testConvert(Samples.helmLoneRibose, converter(NOTATION.FASTA), Samples.fastaRna);
   });
   test('testHelmLoneDeoxyribose', async () => {
-    await _testConvert(Samples.helmLoneDeoxyribose, converter(bio.NOTATION.SEPARATOR, '/'), Samples.separatorDna);
+    await _testConvert(Samples.helmLoneDeoxyribose, converter(NOTATION.SEPARATOR, '/'), Samples.separatorDna);
   });
   test('testHelmLonePhosphorus', async () => {
-    await _testConvert(Samples.helmLonePhosphorus, converter(bio.NOTATION.FASTA), Samples.fastaRna);
+    await _testConvert(Samples.helmLonePhosphorus, converter(NOTATION.FASTA), Samples.fastaRna);
   });
 });

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

@@ -1,10 +1,9 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import * as bio from '@datagrok-libraries/bio';
 
 import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
-import {UnitsHandler} from '@datagrok-libraries/bio';
+import {ALPHABET, getAlphabet, NOTATION, UnitsHandler} from '@datagrok-libraries/bio';
 import {Column} from 'datagrok-api/dg';
 
 category('detectorsBenchmark', () => {
@@ -23,42 +22,42 @@ category('detectorsBenchmark', () => {
   // -- fasta --
 
   test('fastaDnaShorts50Few50', async () => {
-      const et: number = await detectMacromoleculeBenchmark(10, bio.NOTATION.FASTA, bio.ALPHABET.DNA, 50, 50);
+      const et: number = await detectMacromoleculeBenchmark(10, NOTATION.FASTA, ALPHABET.DNA, 50, 50);
     },
     {skipReason: '#1192'});
 
   test('fastaDnaShorts50Many1E6', async () => {
-      const et: number = await detectMacromoleculeBenchmark(10, bio.NOTATION.FASTA, bio.ALPHABET.DNA, 50, 1E6);
+      const et: number = await detectMacromoleculeBenchmark(10, NOTATION.FASTA, ALPHABET.DNA, 50, 1E6);
     },
     {skipReason: '#1192'});
 
   test('fastaDnaLong1e6Few50', async () => {
-      const et: number = await detectMacromoleculeBenchmark(10, bio.NOTATION.FASTA, bio.ALPHABET.DNA, 1E6, 50);
+      const et: number = await detectMacromoleculeBenchmark(10, NOTATION.FASTA, ALPHABET.DNA, 1E6, 50);
     },
     {skipReason: '#1192'});
 
   // -- separator --
 
   test('separatorDnaShorts50Few50', async () => {
-    const et: number = await detectMacromoleculeBenchmark(10, bio.NOTATION.SEPARATOR, bio.ALPHABET.DNA, 50, 50, '/');
+    const et: number = await detectMacromoleculeBenchmark(10, NOTATION.SEPARATOR, ALPHABET.DNA, 50, 50, '/');
   });
 
   test('separatorDnaShorts50Many1E6', async () => {
-      const et: number = await detectMacromoleculeBenchmark(10, bio.NOTATION.SEPARATOR, bio.ALPHABET.DNA, 50, 1E6, '/');
+      const et: number = await detectMacromoleculeBenchmark(10, NOTATION.SEPARATOR, ALPHABET.DNA, 50, 1E6, '/');
     },
     { /* skipReason: 'slow transmit large dataset to detector' */});
 
   test('separatorDnaLong1e6Few50', async () => {
-      const et: number = await detectMacromoleculeBenchmark(10, bio.NOTATION.SEPARATOR, bio.ALPHABET.DNA, 1E6, 50, '/');
+      const et: number = await detectMacromoleculeBenchmark(10, NOTATION.SEPARATOR, ALPHABET.DNA, 1E6, 50, '/');
     },
     {skipReason: '#1192'});
 
   async function detectMacromoleculeBenchmark(
-    maxET: number, notation: bio.NOTATION, alphabet: bio.ALPHABET, length: number, count: number, separator?: string
+    maxET: number, notation: NOTATION, alphabet: ALPHABET, length: number, count: number, separator?: string
   ): Promise<number> {
     return await benchmark<DG.FuncCall, DG.Column>(10,
       (): DG.FuncCall => {
-        const col: DG.Column = generate(notation, [...bio.getAlphabet(alphabet)], length, count, separator);
+        const col: DG.Column = generate(notation, [...getAlphabet(alphabet)], length, count, separator);
         const funcCall: DG.FuncCall = detectFunc.prepare({col: col});
         return funcCall;
       },
@@ -75,11 +74,13 @@ category('detectorsBenchmark', () => {
       });
   }
 
-  function generate(notation: bio.NOTATION, alphabet: string[], length: number, count: number, separator?: string): DG.Column {
+  function generate(
+    notation: NOTATION, alphabet: string[], length: number, count: number, separator?: string
+  ): DG.Column {
     let seqMerger: (seqMList: string[], separator?: string) => string;
 
     switch (notation) {
-    case bio.NOTATION.FASTA:
+    case NOTATION.FASTA:
       seqMerger = (seqMList: string[]): string => {
         let res: string = '';
         for (let j = 0; j < seqMList.length; j++) {
@@ -89,7 +90,7 @@ category('detectorsBenchmark', () => {
         return res;
       };
       break;
-    case bio.NOTATION.SEPARATOR:
+    case NOTATION.SEPARATOR:
       seqMerger = (seqMList: string[], separator?: string): string => {
         return seqMList.join(separator);
       };
@@ -114,7 +115,7 @@ category('detectorsBenchmark', () => {
     return DG.Column.fromStrings('seq', seqList);
   }
 
-  type TgtType = { semType: string, notation: bio.NOTATION, alphabet: bio.ALPHABET, separator?: string };
+  type TgtType = { semType: string, notation: NOTATION, alphabet: ALPHABET, separator?: string };
 
   function testDetector(funcCall: DG.FuncCall): DG.Column {
     //const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: col});
@@ -133,7 +134,6 @@ category('detectorsBenchmark', () => {
     expect(uh.alphabet, tgt.alphabet);
     expect(uh.separator, tgt.separator);
   }
-
 });
 
 
@@ -162,4 +162,3 @@ async function benchmark<TData, TRes>(
 
   return resET;
 }
-

package/src/tests/detectors-tests.ts

@@ -1,11 +1,11 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import * as bio from '@datagrok-libraries/bio';
 
 import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
 
 import {importFasta} from '../package';
+import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS, UnitsHandler} from '@datagrok-libraries/bio';
 
 /*
 // snippet to list df columns of semType='Macromolecule' (false positive)
@@ -214,49 +214,56 @@ MWRSWY-CKHP
   test('NegativeSmiles', async () => { await _testNeg(readCsv('csvDfSmiles', csvDfSmiles), 'col1'); });
 
   test('Dna1', async () => {
-    await _testPos(readCsv('csvDfDna1', csvDfDna1), 'seq', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.DNA, 4, false);
+    await _testPos(readCsv('csvDfDna1', csvDfDna1), 'seq',
+      NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.DNA, 4, false);
   });
   test('Rna1', async () => {
-    await _testPos(readCsv('csvDfRna1', csvDfRna1), 'seq', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.RNA, 4, false);
+    await _testPos(readCsv('csvDfRna1', csvDfRna1), 'seq',
+      NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.RNA, 4, false);
   });
   test('AA1', async () => {
-    await _testPos(readCsv('csvDfPt1', csvDfPt1), 'seq', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.PT, 20, false);
+    await _testPos(readCsv('csvDfPt1', csvDfPt1), 'seq',
+      NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false);
   });
   test('MsaDna1', async () => {
-    await _testPos(readCsv('csvDfMsaDna1', csvDfMsaDna1), 'seq', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ_MSA, bio.ALPHABET.DNA, 4, false);
+    await _testPos(readCsv('csvDfMsaDna1', csvDfMsaDna1), 'seq',
+      NOTATION.FASTA, ALIGNMENT.SEQ_MSA, ALPHABET.DNA, 4, false);
   });
 
   test('MsaAA1', async () => {
-    await _testPos(readCsv('csvDfMsaPt1', csvDfMsaPt1), 'seq', bio.NOTATION.FASTA,
-      bio.ALIGNMENT.SEQ_MSA, bio.ALPHABET.PT, 20, false);
+    await _testPos(readCsv('csvDfMsaPt1', csvDfMsaPt1), 'seq', NOTATION.FASTA,
+      ALIGNMENT.SEQ_MSA, ALPHABET.PT, 20, false);
   });
 
   test('SepDna', async () => {
-    await _testPos(readCsv('csvDfSepDna', csvDfSepDna), 'seq', bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ, bio.ALPHABET.DNA, 4, false, '*');
+    await _testPos(readCsv('csvDfSepDna', csvDfSepDna), 'seq',
+      NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.DNA, 4, false, '*');
   });
   test('SepRna', async () => {
-    await _testPos(readCsv('csvDfSepRna', csvDfSepRna), 'seq', bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ, bio.ALPHABET.RNA, 4, false, '*');
+    await _testPos(readCsv('csvDfSepRna', csvDfSepRna), 'seq',
+      NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.RNA, 4, false, '*');
   });
   test('SepPt', async () => {
     await _testPos(readCsv('csvDfSepPt', csvDfSepPt), 'seq',
-      bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ, bio.ALPHABET.PT, 20, false, '-');
+      NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.PT, 20, false, '-');
   });
   test('SepUn1', async () => {
     await _testPos(readCsv('csvDfSepUn1', csvDfSepUn1), 'seq',
-      bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ, bio.ALPHABET.UN, 8, true, '-');
+      NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.UN, 8, true, '-');
   });
   test('SepUn2', async () => {
     await _testPos(readCsv('csvDfSepUn2', csvDfSepUn2), 'seq',
-      bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ, bio.ALPHABET.UN, 9, true, '/');
+      NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.UN, 9, true, '/');
   });
 
   test('SepMsaN1', async () => {
     await _testPos(readCsv('csvDfSepMsaDna1', csvDfSepMsaDna1), 'seq',
-      bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ_MSA, bio.ALPHABET.DNA, 4, false, '-');
+      NOTATION.SEPARATOR, ALIGNMENT.SEQ_MSA, ALPHABET.DNA, 4, false, '-');
   });
 
   test('SamplesFastaCsvPt', async () => {
-    await _testPos(readSamples(Samples.fastaCsv), 'sequence', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.PT, 20, false);
+    await _testPos(readSamples(Samples.fastaCsv), 'sequence',
+      NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false);
   });
   test('SamplesFastaCsvNegativeEntry', async () => {
     await _testNeg(readSamples(Samples.fastaCsv), 'Entry');
@@ -270,7 +277,7 @@ MWRSWY-CKHP
 
   test('SamplesFastaFastaPt', async () => {
     await _testPos(readSamples(Samples.fastaFasta, readFileFasta),
-      'sequence', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.PT, 20, false);
+      'sequence', NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false);
   });
 
   // peptidesComplex contains monomers with spaces in AlignedSequence columns, which are forbidden
@@ -289,7 +296,7 @@ MWRSWY-CKHP
 
   test('samplesMsaComplexUn', async () => {
     await _testPos(readSamples(Samples.msaComplex), 'MSA',
-      bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ_MSA, bio.ALPHABET.UN, 161, true, '/');
+      NOTATION.SEPARATOR, ALIGNMENT.SEQ_MSA, ALPHABET.UN, 161, true, '/');
   });
   test('samplesMsaComplexNegativeActivity', async () => {
     await _testNeg(readSamples(Samples.msaComplex), 'Activity');
@@ -304,7 +311,8 @@ MWRSWY-CKHP
   });
 
   test('samplesHelmCsvHELM', async () => {
-    await _testPos(readSamples(Samples.helmCsv), 'HELM', bio.NOTATION.HELM, null, null, 160, true, null);
+    await _testPos(readSamples(Samples.helmCsv), 'HELM',
+      NOTATION.HELM, null, null, 160, true, null);
   });
 
   test('samplesHelmCsvNegativeActivity', async () => {
@@ -320,7 +328,7 @@ MWRSWY-CKHP
     await _testNeg(readSamples(Samples.testHelmCsv), 'Test type');
   });
   test('samplesTestHelmPositiveHelmString', async () => {
-    await _testPos(readSamples(Samples.testHelmCsv), 'HELM string', bio.NOTATION.HELM, null, null, 9, true, null);
+    await _testPos(readSamples(Samples.testHelmCsv), 'HELM string', NOTATION.HELM, null, null, 9, true, null);
   });
   test('samplesTestHelmNegativeValid', async () => {
     await _testNeg(readSamples(Samples.testHelmCsv), 'Valid?');
@@ -357,7 +365,7 @@ MWRSWY-CKHP
 
   test('samplesFastaPtPosSequence', async () => {
     await _testPos(readSamples(Samples.fastaPtCsv), 'sequence',
-      bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.PT, 20, false);
+      NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false);
   });
 
   test('samplesTestCerealNegativeCerealName', async () => {
@@ -431,12 +439,12 @@ export async function _testPos(
 
   expect(col.semType === DG.SEMTYPE.MACROMOLECULE, true);
   expect(col.getTag(DG.TAGS.UNITS), units);
-  expect(col.getTag(bio.TAGS.aligned), aligned);
-  expect(col.getTag(bio.TAGS.alphabet), alphabet);
+  expect(col.getTag(bioTAGS.aligned), aligned);
+  expect(col.getTag(bioTAGS.alphabet), alphabet);
   if (separator)
-    expect(col.getTag(bio.TAGS.separator), separator);
+    expect(col.getTag(bioTAGS.separator), separator);
 
-  const uh = new bio.UnitsHandler(col);
+  const uh = new UnitsHandler(col);
   expect(uh.getAlphabetSize(), alphabetSize);
   expect(uh.getAlphabetIsMultichar(), alphabetIsMultichar);
   if (!uh.isHelm()) {
@@ -444,4 +452,3 @@ export async function _testPos(
     expect(uh.alphabet, alphabet);
   }
 }
-

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

@@ -1,15 +1,14 @@
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
-import * as bio from '@datagrok-libraries/bio';
 
 import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
 import {saveAsFastaDo, wrapSequence} from '../utils/save-as-fasta';
+import {splitterAsFasta} from '@datagrok-libraries/bio';
 
 type SaveAsFastaTestArgs = { srcCsv: string, idCols: string [], seqCol: string, lineWidth: number, tgtFasta: string };
 
 category('fastaExport', () => {
-
   enum WrapDataTest {
     single = 'single',
     multi = 'multi'
@@ -88,7 +87,7 @@ MRGGL
   });
 
   function _testWrapSequence(testKey: string, lineWidth: number = 10) {
-    const splitter = bio.splitterAsFasta;
+    const splitter = splitterAsFasta;
 
     const srcSeq: string = wrapData[testKey].src;
     const wrapRes: string[] = wrapSequence(srcSeq, splitter, lineWidth);