@datagrok/bio 2.15.13 → 2.16.0

package/src/tests/WebLogo-positions-test.ts

@@ -1,9 +1,10 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {category, expect, expectArray, test, testEvent} from '@datagrok-libraries/utils/src/test';
+import {before, category, expect, expectArray, test, testEvent} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, NOTATION, TAGS as bioTAGS} 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 {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
 import {
   countForMonomerAtPosition,
@@ -11,11 +12,16 @@ import {
   PositionMonomerInfo as PMI,
   WebLogoViewer,
 } from '../viewers/web-logo-viewer';
-import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
 const g: string = GAP_SYMBOL;
 
-category('WebLogo-positions', () => {
+category('WebLogo.positions', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   const csvDf1 = `seq
 ATC-G-TTGC--
 ATC-G-TTGC--
@@ -182,7 +188,7 @@ ATC-G-TTGC--
     }
 
     const atPI1: PI = resPosList[1];
-    const sh = SeqHandler.forColumn(seqCol);
+    const sh = seqHelper.getSeqHandler(seqCol);
     const countAt1 = countForMonomerAtPosition(df, sh, df.filter, 'G', atPI1);
     expect(countAt1, 5);
     await wlViewer.awaitRendered();

package/src/tests/WebLogo-project-tests.ts

@@ -13,7 +13,7 @@ import {_package} from '../package-test';
 
 const PROJECT_PREFIX: string = 'Tests.Bio.WebLogo-project';
 
-category('WebLogo-project', () => {
+category('WebLogo.project', () => {
   test('fasta', async () => {
     const prjName = `${PROJECT_PREFIX}.fasta`;
     const df = await _package.files.readCsv('tests/filter_FASTA.csv');

package/src/tests/activity-cliffs-utils.ts

@@ -2,7 +2,6 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
 import {expect} from '@datagrok-libraries/utils/src/test';
-import {activityCliffs} from '../package';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {BitArrayMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {BYPASS_LARGE_DATA_WARNING} from '@datagrok-libraries/ml/src/functionEditors/consts';
@@ -13,19 +12,17 @@ export async function _testActivityCliffsOpen(df: DG.DataFrame, drMethod: DimRed
   similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics, preprocessingFunction: DG.Func,
 ): Promise<void> {
   await grok.data.detectSemanticTypes(df);
-  const scatterPlot = await activityCliffs(
-    df, df.getCol(seqColName), df.getCol(activityColName),
-    similarityThr, drMethod, similarityMetric, preprocessingFunction, {[`${BYPASS_LARGE_DATA_WARNING}`]: true});
-  // const scatterPlot = (await grok.functions.call('Bio:activityCliffs', {
-  //   table: df, molecules: df.getCol(colName), activities: df.getCol('Activity'),
-  //   similarity: 50, methodName: method
-  // })) as DG.Viewer | undefined;
-
-  // test scatter plot without activityCliffs passed
-  // const scatterPlot = (await df.plot.fromType(DG.VIEWER.SCATTER_PLOT, {})) as DG.Viewer;
-  // const libHelper: IMonomerLibHelper = (await grok.functions.call('Bio:getMonomerLibHelper'));
-  // const k = 11;
-
+  const scatterPlot = (await grok.functions.call('Bio:activityCliffs', {
+    table: df,
+    molecules: df.getCol(seqColName),
+    activities: df.getCol(activityColName),
+    similarity: similarityThr,
+    methodName: drMethod,
+    similarityMetric: similarityMetric,
+    preprocessingFunction: preprocessingFunction,
+    options: {[`${BYPASS_LARGE_DATA_WARNING}`]: true},
+    demo: false,
+  })) as DG.Viewer | undefined;
   expect(scatterPlot != null, true);
 
   const cliffsLink = Array.from(scatterPlot!.root.children).find((el) => {

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