@datagrok/bio 2.1.11 → 2.4.2

package/src/substructure-search/substructure-search.ts

@@ -1,12 +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 * as C from '../utils/constants';
 import {getMonomericMols} from '../calculations/monomerLevelMols';
 import {updateDivInnerHTML} from '../utils/ui-utils';
-import { delay } from '@datagrok-libraries/utils/src/test';
+import {delay} from '@datagrok-libraries/utils/src/test';
+import {TAGS as bioTAGS, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 export const MONOMER_MOLS_COL = 'monomeric-mols';
 
@@ -16,14 +15,16 @@ export const enum MONOMERIC_COL_TAGS {
   MONOMERS_DICT = 'monomers-dict'
 }
 
+const SUBSTR_HELM_COL_NAME = 'substr_helm';
+
 /**
  * Searches substructure in each row of Macromolecule column
  *
  * @param {DG.column} col Column with 'Macromolecule' semantic type
  */
-export function substructureSearchDialog(col: DG.Column): void {
+export function substructureSearchDialog(col: DG.Column<string>): void {
   const units = col.getTag(DG.TAGS.UNITS);
-  const separator = col.getTag(C.TAGS.SEPARATOR);
+  const separator = col.getTag(bioTAGS.separator);
   // const notations = [NOTATION.FASTA, NOTATION.SEPARATOR, NOTATION.HELM];
 
   const substructureInput = ui.textInput('Substructure', '');
@@ -32,40 +33,41 @@ export function substructureSearchDialog(col: DG.Column): void {
     updateDivInnerHTML(inputsDiv, grid.root);
     await ui.tools.waitForElementInDom(grid.root);
     setTimeout(() => {
-      grid.cell('substr_helm', 0).element.children[0].dispatchEvent(new KeyboardEvent('keydown', {key: 'Enter'}));
+      grid.cell(SUBSTR_HELM_COL_NAME, 0).element.children[0].dispatchEvent(
+        new KeyboardEvent('keydown', {key: 'Enter'}));
     }, 100);
   });
 
   const df = DG.DataFrame.create(1);
-  df.columns.addNewString('substr_helm').init((i) => '');
-  df.col('substr_helm')!.semType = col.semType;
-  df.col('substr_helm')!.setTag(DG.TAGS.UNITS, bio.NOTATION.HELM);
+  df.columns.addNewString(SUBSTR_HELM_COL_NAME).init((i) => '');
+  df.col(SUBSTR_HELM_COL_NAME)!.semType = col.semType;
+  df.col(SUBSTR_HELM_COL_NAME)!.setTag(DG.TAGS.UNITS, NOTATION.HELM);
   const grid = df.plot.grid();
   const separatorInput = ui.textInput('Separator', separator);
 
   const inputsDiv = ui.div();
 
-  const inputs = units === bio.NOTATION.HELM ? ui.divV([editHelmLink]) :
-    units === bio.NOTATION.SEPARATOR ? ui.inputs([substructureInput, separatorInput]) :
+  const inputs = units === NOTATION.HELM ? ui.divV([editHelmLink]) :
+    units === NOTATION.SEPARATOR ? ui.inputs([substructureInput, separatorInput]) :
       ui.inputs([substructureInput]);
 
   updateDivInnerHTML(inputsDiv, inputs);
 
-  ui.dialog('Substructure search')
+  ui.dialog('Substructure Search')
     .add(ui.divV([
       ui.divText(`Notation: ${units}`),
       inputsDiv
     ]))
     .onOK(async () => {
-      let substructure = units === bio.NOTATION.HELM ? df.get('substr_helm', 0) : substructureInput.value;
-      if (units === bio.NOTATION.SEPARATOR && separatorInput.value !== separator && separatorInput.value !== '')
+      let substructure = units === NOTATION.HELM ? df.get(SUBSTR_HELM_COL_NAME, 0) : substructureInput.value;
+      if (units === NOTATION.SEPARATOR && separatorInput.value !== separator && separatorInput.value !== '')
         substructure = substructure.replaceAll(separatorInput.value, separator);
       const matchesColName = `Matches: ${substructure}`;
       const colExists = col.dataFrame.columns.names()
         .filter((it) => it.toLocaleLowerCase() === matchesColName.toLocaleLowerCase()).length > 0;
       if (!colExists) {
         let matches: DG.BitSet;
-        if (units === bio.NOTATION.HELM)
+        if (units === NOTATION.HELM)
           matches = await helmSubstructureSearch(substructure, col);
         else
           matches = linearSubstructureSearch(substructure, col);
@@ -75,11 +77,11 @@ export function substructureSearchDialog(col: DG.Column): void {
     .show();
 }
 
-export function linearSubstructureSearch(substructure: string, col: DG.Column, separator?: string): DG.BitSet {
+export function linearSubstructureSearch(substructure: string, col: DG.Column<string>, separator?: string): DG.BitSet {
   const re = separator ? prepareSubstructureRegex(substructure, separator) : substructure;
   const resultArray = DG.BitSet.create(col.length);
   for (let i = 0; i < col.length; i++) {
-    const macromolecule = col.get(i);
+    const macromolecule: string = col.get(i)!;
     if (macromolecule.match(re) || macromolecule === substructure)
       resultArray.set(i, true, false);
   }
@@ -91,18 +93,19 @@ function prepareSubstructureRegex(substructure: string, separator: string) {
   const startsWithSep = substructure.charAt(0) === separator;
   const endsWithSep = substructure.charAt(substructure.length - 1) === separator;
   const substrWithoutSep = substructure.replace(new RegExp(`^${char}|${char}$`, 'g'), '');
-  const re = startsWithSep ? endsWithSep ? `${char}${substrWithoutSep}${char}` :
+  const re = startsWithSep ?
+    endsWithSep ? `${char}${substrWithoutSep}${char}` :
       `${char}${substrWithoutSep}${char}|${char}${substrWithoutSep}$` :
     endsWithSep ? `^${substrWithoutSep}${char}|${char}${substrWithoutSep}${char}` :
       `^${substrWithoutSep}${char}|${char}${substrWithoutSep}${char}|${char}${substrWithoutSep}$`;
   return re;
 }
 
-export async function helmSubstructureSearch(substructure: string, col: DG.Column): Promise<DG.BitSet> {
+export async function helmSubstructureSearch(substructure: string, col: DG.Column<string>): Promise<DG.BitSet> {
   if (col.version !== col.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION])
     await invalidateMols(col, true);
-  const substructureCol = DG.Column.string('helm', 1).init((i) => substructure);
-  substructureCol.setTag(DG.TAGS.UNITS, bio.NOTATION.HELM);
+  const substructureCol: DG.Column<string> = DG.Column.string('helm', 1).init((i) => substructure);
+  substructureCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
   const substructureMolsCol =
     await getMonomericMols(substructureCol, true, col.temp[MONOMERIC_COL_TAGS.MONOMERS_DICT]);
   const matchesCol = await grok.functions.call('Chem:searchSubstructure', {
@@ -113,7 +116,7 @@ export async function helmSubstructureSearch(substructure: string, col: DG.Colum
   return matchesCol.get(0);
 }
 
-export async function invalidateMols(col: DG.Column, pattern: boolean) {
+export async function invalidateMols(col: DG.Column<string>, pattern: boolean) {
   const progressBar = DG.TaskBarProgressIndicator.create(`Invalidating molfiles for ${col.name}`);
   await delay(10);
   const monomersDict = new Map();

package/src/tests/Palettes-test.ts

@@ -1,26 +1,26 @@
 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 {_testPaletteN, _testPaletteAA} from '@datagrok-libraries/bio/src/tests/palettes-tests';
+import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
 
 category('Palettes', () => {
   test('testPaletteN', async () => { await _testPaletteN(); });
   test('testPaletteAA', async () => { await _testPaletteAA(); });
 
   test('testPalettePtMe', async () => {
-    const colorMeNle = bio.AminoacidsPalettes.GrokGroups.get('MeNle');
-    const colorMeA = bio.AminoacidsPalettes.GrokGroups.get('MeA');
-    const colorMeG = bio.AminoacidsPalettes.GrokGroups.get('MeG');
-    const colorMeF = bio.AminoacidsPalettes.GrokGroups.get('MeF');
+    const colorMeNle = AminoacidsPalettes.GrokGroups.get('MeNle');
+    const colorMeA = AminoacidsPalettes.GrokGroups.get('MeA');
+    const colorMeG = AminoacidsPalettes.GrokGroups.get('MeG');
+    const colorMeF = AminoacidsPalettes.GrokGroups.get('MeF');
 
-    const colorL = bio.AminoacidsPalettes.GrokGroups.get('L');
-    const colorA = bio.AminoacidsPalettes.GrokGroups.get('A');
-    const colorG = bio.AminoacidsPalettes.GrokGroups.get('G');
-    const colorF = bio.AminoacidsPalettes.GrokGroups.get('F');
+    const colorL = AminoacidsPalettes.GrokGroups.get('L');
+    const colorA = AminoacidsPalettes.GrokGroups.get('A');
+    const colorG = AminoacidsPalettes.GrokGroups.get('G');
+    const colorF = AminoacidsPalettes.GrokGroups.get('F');
 
     expect(colorMeNle, colorL);
     expect(colorMeA, colorA);

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

@@ -1,9 +1,15 @@
 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, delay} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {ALPHABET, NOTATION, SplitterFunc, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {
+  countForMonomerAtPosition,
+  FilterSources,
+  PositionInfo as PI,
+  PositionMonomerInfo as PMI,
+  WebLogoViewer
+} from '../viewers/web-logo-viewer';
 
 category('WebLogo-positions', () => {
   let tvList: DG.TableView[];
@@ -21,13 +27,14 @@ ATC-G-TTGC--
   before(async () => {
     tvList = [];
     dfList = [];
-    currentView = grok.shell.v;
+    // currentView = grok.shell.v;
   });
 
   after(async () => {
-    dfList.forEach((df: DG.DataFrame) => { grok.shell.closeTable(df);});
-    tvList.forEach((tv: DG.TableView) => tv.close());
-    grok.shell.v = currentView;
+    // Closing opened views causes the error 'Cannot read properties of null (reading 'f')'
+    // dfList.forEach((df: DG.DataFrame) => { grok.shell.closeTable(df); });
+    // tvList.forEach((tv: DG.TableView) => tv.close());
+    // grok.shell.v = currentView;
   });
 
   test('allPositions', async () => {
@@ -36,31 +43,31 @@ ATC-G-TTGC--
 
     const seqCol: DG.Column = df.getCol('seq');
     seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
-    seqCol.setTag(DG.TAGS.UNITS, bio.NOTATION.FASTA);
-    seqCol.setTag(bio.TAGS.alphabet, bio.ALPHABET.DNA);
-    seqCol.setTag(bio.TAGS.aligned, 'SEQ.MSA');
+    seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    seqCol.setTag(bioTAGS.alphabet, ALPHABET.DNA);
+    seqCol.setTag(bioTAGS.aligned, 'SEQ.MSA');
 
-    const wlViewer: bio.WebLogoViewer = (await df.plot.fromType('WebLogo')) as bio.WebLogoViewer;
+    const wlViewer: WebLogoViewer = (await df.plot.fromType('WebLogo')) as WebLogoViewer;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
 
     tvList.push(tv);
     dfList.push(df);
 
-    const positions: bio.PositionInfo[] = wlViewer['positions'];
-
-    const resAllDf1: bio.PositionInfo[] = [
-      new bio.PositionInfo('1', {'A': new bio.PositionMonomerInfo(2), '-': new bio.PositionMonomerInfo(3)}),
-      new bio.PositionInfo('2', {'T': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('3', {'C': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('4', {'-': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('5', {'G': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('6', {'-': new bio.PositionMonomerInfo(3), 'C': new bio.PositionMonomerInfo(2)}),
-      new bio.PositionInfo('7', {'T': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('8', {'T': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('9', {'G': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('10', {'C': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('11', {'-': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('12', {'-': new bio.PositionMonomerInfo(5)}),
+    const positions: PI[] = wlViewer['positions'];
+
+    const resAllDf1: PI[] = [
+      new PI(0, '1', {'A': new PMI(2), '-': new PMI(3)}),
+      new PI(1, '2', {'T': new PMI(5)}),
+      new PI(2, '3', {'C': new PMI(5)}),
+      new PI(3, '4', {'-': new PMI(5)}),
+      new PI(4, '5', {'G': new PMI(5)}),
+      new PI(5, '6', {'-': new PMI(3), 'C': new PMI(2)}),
+      new PI(6, '7', {'T': new PMI(5)}),
+      new PI(7, '8', {'T': new PMI(5)}),
+      new PI(8, '9', {'G': new PMI(5)}),
+      new PI(9, '10', {'C': new PMI(5)}),
+      new PI(10, '11', {'-': new PMI(5)}),
+      new PI(11, '12', {'-': new PMI(5)}),
     ];
 
     expect(positions.length, resAllDf1.length);
@@ -73,8 +80,8 @@ ATC-G-TTGC--
     }
   });
 
-  test('positions with shrinkEmptyTail option true (filterd)', async () => {
-    let csvDf2 = `seq 
+  test('positions with shrinkEmptyTail option true (filtered)', async () => {
+    const csvDf2 = `seq 
 -TC-G-TTGC--
 -TC-GCTTGC--
 -T--C-GT-
@@ -86,33 +93,33 @@ ATC-G-TTGC--
 
     const seqCol: DG.Column = df.getCol('seq');
     seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
-    seqCol.setTag(DG.TAGS.UNITS, bio.NOTATION.FASTA);
-    seqCol.setTag(bio.TAGS.alphabet, bio.ALPHABET.DNA);
-    seqCol.setTag(bio.TAGS.aligned, 'SEQ');
+    seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    seqCol.setTag(bioTAGS.alphabet, ALPHABET.DNA);
+    seqCol.setTag(bioTAGS.aligned, 'SEQ');
 
     df.filter.init((i) => {
       return i > 2;
     });
     df.filter.fireChanged();
-    const wlViewer: bio.WebLogoViewer = (await df.plot.fromType('WebLogo',
-      {'shrinkEmptyTail': true})) as bio.WebLogoViewer;
+    const wlViewer: WebLogoViewer = (await df.plot.fromType('WebLogo',
+      {'shrinkEmptyTail': true})) as WebLogoViewer;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
 
     tvList.push(tv);
     dfList.push(df);
 
-    const positions: bio.PositionInfo[] = wlViewer['positions'];
-
-    const resAllDf1: bio.PositionInfo[] = [
-      new bio.PositionInfo('1', {'-': new bio.PositionMonomerInfo(3)}),
-      new bio.PositionInfo('2', {'T': new bio.PositionMonomerInfo(3)}),
-      new bio.PositionInfo('3', {'-': new bio.PositionMonomerInfo(3)}),
-      new bio.PositionInfo('4', {'-': new bio.PositionMonomerInfo(3)}),
-      new bio.PositionInfo('5', {'C': new bio.PositionMonomerInfo(3)}),
-      new bio.PositionInfo('6', {'-': new bio.PositionMonomerInfo(2), 'C': new bio.PositionMonomerInfo(1)}),
-      new bio.PositionInfo('7', {'G': new bio.PositionMonomerInfo(3)}),
-      new bio.PositionInfo('8', {'T': new bio.PositionMonomerInfo(3)}),
-      new bio.PositionInfo('9', {'-': new bio.PositionMonomerInfo(3)}),
+    const positions: PI[] = wlViewer['positions'];
+
+    const resAllDf1: PI[] = [
+      new PI(0, '1', {'-': new PMI(3)}),
+      new PI(1, '2', {'T': new PMI(3)}),
+      new PI(2, '3', {'-': new PMI(3)}),
+      new PI(3, '4', {'-': new PMI(3)}),
+      new PI(4, '5', {'C': new PMI(3)}),
+      new PI(5, '6', {'-': new PMI(2), 'C': new PMI(1)}),
+      new PI(6, '7', {'G': new PMI(3)}),
+      new PI(7, '8', {'T': new PMI(3)}),
+      new PI(8, '9', {'-': new PMI(3)}),
     ];
 
     expect(positions.length, resAllDf1.length);
@@ -131,38 +138,94 @@ ATC-G-TTGC--
 
     const seqCol: DG.Column = df.getCol('seq');
     seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
-    seqCol.setTag(DG.TAGS.UNITS, bio.NOTATION.FASTA);
-    seqCol.setTag(bio.TAGS.alphabet, bio.ALPHABET.DNA);
-    seqCol.setTag(bio.TAGS.aligned, 'SEQ.MSA');
+    seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    seqCol.setTag(bioTAGS.alphabet, ALPHABET.DNA);
+    seqCol.setTag(bioTAGS.aligned, 'SEQ.MSA');
 
-    const wlViewer: bio.WebLogoViewer = (await df.plot.fromType('WebLogo',
-      {'skipEmptyPositions': true})) as bio.WebLogoViewer;
+    const wlViewer: WebLogoViewer = (await df.plot.fromType('WebLogo',
+      {'skipEmptyPositions': true})) as WebLogoViewer;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
 
     tvList.push(tv);
     dfList.push(df);
 
-    const positions: bio.PositionInfo[] = wlViewer['positions'];
-
-    const resAllDf1: bio.PositionInfo[] = [
-      new bio.PositionInfo('1', {'A': new bio.PositionMonomerInfo(2), '-': new bio.PositionMonomerInfo(3)}),
-      new bio.PositionInfo('2', {'T': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('3', {'C': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('5', {'G': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('6', {'-': new bio.PositionMonomerInfo(3), 'C': new bio.PositionMonomerInfo(2)}),
-      new bio.PositionInfo('7', {'T': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('8', {'T': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('9', {'G': new bio.PositionMonomerInfo(5)}),
-      new bio.PositionInfo('10', {'C': new bio.PositionMonomerInfo(5)})
+    const resPosList: PI[] = wlViewer['positions'];
+
+    const tgtPosList: PI[] = [
+      new PI(0, '1', {'A': new PMI(2), '-': new PMI(3)}),
+      new PI(1, '2', {'T': new PMI(5)}),
+      new PI(2, '3', {'C': new PMI(5)}),
+      new PI(4, '5', {'G': new PMI(5)}),
+      new PI(5, '6', {'-': new PMI(3), 'C': new PMI(2)}),
+      new PI(6, '7', {'T': new PMI(5)}),
+      new PI(7, '8', {'T': new PMI(5)}),
+      new PI(8, '9', {'G': new PMI(5)}),
+      new PI(9, '10', {'C': new PMI(5)})
     ];
 
-    expect(positions.length, resAllDf1.length);
+    expect(resPosList.length, tgtPosList.length);
+    for (let posI = 0; posI < resPosList.length; posI++) {
+      const resPos = resPosList[posI];
+      const tgtPos = tgtPosList[posI];
+      expectPositionInfo(resPos, tgtPos);
+    }
+  });
 
-    for (let i = 0; i < positions.length; i++) {
-      expect(positions[i].name, resAllDf1[i].name);
-      for (const key in positions[i].freq) {
-        expect(positions[i].freq[key].count, resAllDf1[i].freq[key].count);
-      }
+  test('count sequences for monomer at position', async () => {
+    const df: DG.DataFrame = buildDfWithSeqCol(csvDf1, NOTATION.FASTA, ALPHABET.DNA, 'SEQ.MSA');
+    const seqCol: DG.Column = df.getCol('seq');
+
+    const tv: DG.TableView = grok.shell.addTableView(df);
+
+    const wlViewer: WebLogoViewer = (await df.plot.fromType('WebLogo', {
+      startPositionName: '3',
+      endPositionName: '7',
+      skipEmptyPositions: true
+    })) as WebLogoViewer;
+    tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
+
+    tvList.push(tv);
+    dfList.push(df);
+
+    const resPosList: PI[] = wlViewer['positions'];
+    const tgtPosList: PI[] = [
+      new PI(2, '3', {'C': new PMI(5)}),
+      new PI(4, '5', {'G': new PMI(5)}),
+      new PI(5, '6', {'-': new PMI(3), 'C': new PMI(2)}),
+      new PI(6, '7', {'T': new PMI(5)}),
+    ];
+
+    expect(resPosList.length, tgtPosList.length);
+    for (let posI = 0; posI < resPosList.length; posI++) {
+      const resPos = resPosList[posI];
+      const tgtPos = tgtPosList[posI];
+      expectPositionInfo(resPos, tgtPos);
     }
+
+    const splitter: SplitterFunc = wlViewer['splitter']!;
+    const atPI1: PI = resPosList[1];
+    const countAt1 = countForMonomerAtPosition(df, seqCol, df.filter, splitter, 'G', atPI1);
+    expect(countAt1, 5);
   });
 });
+
+function expectPositionInfo(actualPos: PI, expectedPos: PI): void {
+  expect(actualPos.name, expectedPos.name);
+  expectArray(Object.keys(actualPos.freq), Object.keys(expectedPos.freq));
+  for (const key in actualPos.freq) {
+    //
+    expect(actualPos.freq[key].count, expectedPos.freq[key].count);
+  }
+}
+
+function buildDfWithSeqCol(csv: string, notation: NOTATION, alphabet: ALPHABET, aligned: string): DG.DataFrame {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+
+  const seqCol: DG.Column = df.getCol('seq');
+  seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+  seqCol.setTag(DG.TAGS.UNITS, notation);
+  seqCol.setTag(bioTAGS.alphabet, alphabet);
+  seqCol.setTag(bioTAGS.aligned, aligned);
+
+  return df;
+}

package/src/tests/_first-tests.ts

@@ -0,0 +1,9 @@
+import * as DG from 'datagrok-api/dg';
+
+import {category, expect, test} from '@datagrok-libraries/utils/src/test';
+
+category('_first', () => {
+  /** The first test of the package to evaluate problems with imports. */
+  test('_first', async () => {
+  });
+});

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

@@ -1,7 +1,8 @@
-import {after, before, category, test} from '@datagrok-libraries/utils/src/test';
-
-import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {after, before, category, test} from '@datagrok-libraries/utils/src/test';
 
 import {readDataframe} from './utils';
 import {_testActivityCliffsOpen} from './activity-cliffs-utils';
@@ -22,8 +23,8 @@ category('activityCliffs', async () => {
   });
 
   after(async () => {
-    for (const view of viewList) view.close();
-    for (const df of dfList) grok.shell.closeTable(df);
+    // for (const df of dfList) grok.shell.closeTable(df);
+    // for (const view of viewList) view.close();
   });
 
   test('activityCliffsOpens', async () => {
@@ -33,7 +34,7 @@ category('activityCliffs', async () => {
     viewList.push(actCliffsTableView);
 
     await _testActivityCliffsOpen(actCliffsDf, 57, 'UMAP', 'MSA');
-  });
+  }, {skipReason: 'GROK-12774'});
 
   test('activityCliffsWithEmptyRows', async () => {
     actCliffsDfWithEmptyRows = await readDataframe('tests/sample_MSA_data_empty_vals.csv');
@@ -42,5 +43,5 @@ category('activityCliffs', async () => {
     viewList.push(actCliffsTableViewWithEmptyRows);
 
     await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 57, 'UMAP', 'MSA');
-  });
+  }, {skipReason: 'GROK-12774'});
 });

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

@@ -2,20 +2,28 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
 import {delay, expect} from '@datagrok-libraries/utils/src/test';
-import {_package} from '../package-test';
 import {activityCliffs} from '../package';
 
 export async function _testActivityCliffsOpen(df: DG.DataFrame, numberCliffs: number, method: string, colName: string) {
   await grok.data.detectSemanticTypes(df);
   const scatterPlot = await activityCliffs(
-    df,
-    df.col(colName)!,
-    df.col('Activity')!,
-    50,
-    method);
+    df, df.getCol(colName), df.getCol('Activity'),
+    50, method);
+  // 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;
 
   expect(scatterPlot != null, true);
 
-  const cliffsLink = Array.from(scatterPlot!.root.children).filter(it => it.className === 'ui-btn ui-btn-ok');
-  expect((cliffsLink[0] as HTMLElement).innerText.toLowerCase(), `${numberCliffs} cliffs`);
-}
+  const cliffsLink = Array.from(scatterPlot!.root.children).find((el) => {
+    const classList: string[] = el.className.split(' ');
+    return ['ui-btn', 'ui-btn-ok'].every((reqClassName) => classList.includes(reqClassName));
+  });
+  expect((cliffsLink as HTMLElement).innerText.toLowerCase(), `${numberCliffs} cliffs`);
+}

package/src/tests/bio-tests.ts

@@ -1,9 +1,19 @@
 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 {
+  getAlphabetSimilarity,
+  getStats,
+  monomerToShort,
+  pickUpPalette,
+  splitterAsFasta,
+  splitterAsHelm,
+} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {Nucleotides, NucleotidesPalettes} from '@datagrok-libraries/bio/src/nucleotides';
+import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
+import {UnknownSeqPalette} from '@datagrok-libraries/bio/src/unknown';
 
 category('bio', () => {
   const csvDfN1: string = `seq
@@ -53,7 +63,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 +82,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 +102,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 +121,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 +130,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);
 }
-