@datagrok/bio 2.1.11 → 2.4.2

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/src/utils/macromolecule';
 
 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,12 @@
 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} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 // import {mmSemType} from '../const';
 // import {importFasta} from '../package';
@@ -28,6 +29,10 @@ category('converters', () => {
     separatorGaps = 'separatorGaps',
     helmGaps = 'helmGaps',
 
+    fastaUn = 'fastaUn',
+    separatorUn = 'separatorUn',
+    helmUn = 'helmUn',
+
     helmLoneDeoxyribose = 'helmLoneDeoxyribose',
     helmLoneRibose = 'helmLoneRibose',
     helmLonePhosphorus = 'helmLonePhosphorus',
@@ -96,6 +101,22 @@ F/K/P//Q//S/E/Y/V
 PEPTIDE1{F.W.*.P.H.*.E.Y.Y}$$$
 PEPTIDE1{F.Y.N.R.Q.W.Y.V.*}$$$
 PEPTIDE1{F.K.P.*.Q.*.S.E.Y.V}$$$
+`,
+
+    fastaUn: `seq
+[meI][hHis][Aca]NT[dE][Thr_PO3H2][Aca]D
+[meI][hHis][Aca][Cys_SEt]T[dK][Thr_PO3H2][Aca][Tyr_PO3H2]
+[Lys_Boc][hHis][Aca][Cys_SEt]T[dK][Thr_PO3H2][Aca][Tyr_PO3H2]
+`,
+    separatorUn: `seq
+meI-hHis-Aca-N-T-dE-Thr_PO3H2-Aca-D
+meI-hHis-Aca-Cys_SEt-T-dK-Thr_PO3H2-Aca-Tyr_PO3H2
+Lys_Boc-hHis-Aca-Cys_SEt-T-dK-Thr_PO3H2-Aca-Tyr_PO3H2
+`,
+    helmUn: `seq
+PEPTIDE1{meI.hHis.Aca.N.T.dE.Thr_PO3H2.Aca.D}$$$
+PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2}$$$
+PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2}$$$
 `,
     helmLoneDeoxyribose: `seq
 DNA1{D(A).D(C).D(G).D(T).D(C)}$$$
@@ -114,37 +135,31 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
 `,
   };
 
-  const _csvDfs: { [key: string]: Promise<DG.DataFrame> } = {};
-
   /** Also detects semantic types
    * @param {string} key
    * @return {Promise<DG.DataFrame>}
    */
-  function readCsv(key: string): Promise<DG.DataFrame> {
-    if (!(key in _csvDfs)) {
-      _csvDfs[key] = (async (): Promise<DG.DataFrame> => {
-        const csv: string = _csvTxts[key];
-        const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
-        await grok.data.detectSemanticTypes(df);
-        return df;
-      })();
-    }
-    return _csvDfs[key];
-  };
+  async function readCsv(key: string): Promise<DG.DataFrame> {
+    // Always recreate test data frame from CSV for reproducible detector behavior in tests.
+    const csv: string = _csvTxts[key];
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+    await grok.data.detectSemanticTypes(df);
+    return df;
+  }
 
-  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;
     };
-  };
+  }
 
-  async function _testConvert(srcKey: string, converter: ConverterFunc, tgtKey: string) {
+  async function _testConvert(srcKey: Samples, converter: ConverterFunc, tgtKey: Samples) {
     const srcDf: DG.DataFrame = await readCsv(srcKey);
     const srcCol: DG.Column = srcDf.getCol('seq');
 
@@ -156,100 +171,120 @@ 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);
+  });
+  test('testFastaUnToSeparator', async () => {
+    await _testConvert(Samples.fastaUn, converter(NOTATION.SEPARATOR, '-'), Samples.separatorUn);
   });
 
   // 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);
   });
+  // TODO: testFastaUnToHelm
+  // test('testFastaUnToHelm', async () => {
+  //   await _testConvert(Samples.fastaUn, converter(NOTATION.HELM), Samples.helmUn);
+  // });
 
 
   // 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);
+  });
+  test('testSeparatorUnToFasta', async () => {
+    await _testConvert(Samples.separatorUn, converter(NOTATION.FASTA), Samples.fastaUn);
   });
 
   // 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);
   });
+  // TODO: testSeparatorUnToHelm
+  // test('testSeparatorUnToHelm', async () => {
+  //   await _testConvert(Samples.separatorUn, converter(NOTATION.HELM), Samples.helmUn);
+  // });
 
 
   // 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);
+  });
+  test('testHelmUnToFasta', async () => {
+    await _testConvert(Samples.helmUn, converter(NOTATION.FASTA), Samples.fastaUn);
   });
 
   // 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);
+  });
+  test('testHelmUnToSeparator', async () => {
+    await _testConvert(Samples.helmUn, converter(NOTATION.SEPARATOR, '-'), Samples.separatorUn);
   });
 
   // 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,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 {UnitsHandler} from '@datagrok-libraries/bio';
+import {ALPHABET, getAlphabet, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {Column} from 'datagrok-api/dg';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 category('detectorsBenchmark', () => {
 
@@ -23,42 +23,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, '/');
+  }, {skipReason: '#1192'});
 
   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 +75,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 +91,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 +116,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 +135,6 @@ category('detectorsBenchmark', () => {
     expect(uh.alphabet, tgt.alphabet);
     expect(uh.separator, tgt.separator);
   }
-
 });
 
 
@@ -162,4 +163,3 @@ async function benchmark<TData, TRes>(
 
   return resET;
 }
-