@datagrok/bio 2.1.11 → 2.4.2

package/src/tests/renderers-test.ts

@@ -1,14 +1,15 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
-import * as bio from '@datagrok-libraries/bio';
 
 import {after, before, category, delay, expect, test} from '@datagrok-libraries/utils/src/test';
 
 import {importFasta, multipleSequenceAlignmentAny} from '../package';
 import {convertDo} from '../utils/convert';
-import {SEM_TYPES, TAGS} from '../utils/constants';
+import * as C from '../utils/constants';
 import {generateLongSequence, generateManySequences, performanceTest} from './utils/sequences-generators';
 import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
+import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 category('renderers', () => {
   let tvList: DG.TableView[];
@@ -20,8 +21,9 @@ category('renderers', () => {
   });
 
   after(async () => {
-    dfList.forEach((df: DG.DataFrame) => { grok.shell.closeTable(df); });
-    tvList.forEach((tv: DG.TableView) => tv.close());
+    // Closing viewes and data frames leads to exception
+    // dfList.forEach((df: DG.DataFrame) => { grok.shell.closeTable(df); });
+    // tvList.forEach((tv: DG.TableView) => tv.close());
   });
 
   test('long sequence performance ', async () => {
@@ -50,7 +52,7 @@ category('renderers', () => {
 
   test('afterConvert', async () => {
     await _testAfterConvert();
-  });
+  }, {skipReason: 'GROK-12765'});
 
   test('selectRendererBySemType', async () => {
     await _selectRendererBySemType();
@@ -103,9 +105,9 @@ category('renderers', () => {
   async function _rendererMacromoleculeDifference() {
     const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
       ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
-    seqDiffCol.tags[DG.TAGS.UNITS] = bio.NOTATION.SEPARATOR;
-    seqDiffCol.tags[TAGS.SEPARATOR] = '/';
-    seqDiffCol.semType = SEM_TYPES.MACROMOLECULE_DIFFERENCE;
+    seqDiffCol.tags[DG.TAGS.UNITS] = NOTATION.SEPARATOR;
+    seqDiffCol.tags[bioTAGS.separator] = '/';
+    seqDiffCol.semType = C.SEM_TYPES.MACROMOLECULE_DIFFERENCE;
     const df = DG.DataFrame.fromColumns([seqDiffCol]);
 
     const tv: DG.TableView = grok.shell.addTableView(df);
@@ -116,7 +118,7 @@ category('renderers', () => {
     tvList.push(tv);
 
     const resCellRenderer = seqDiffCol.getTag(DG.TAGS.CELL_RENDERER);
-    expect(resCellRenderer, 'MacromoleculeDifference');
+    expect(resCellRenderer, C.SEM_TYPES.MACROMOLECULE_DIFFERENCE);
   }
 
   async function _testAfterMsa() {
@@ -138,22 +140,22 @@ category('renderers', () => {
       `semType="${srcSeqCol!.semType}", units="${srcSeqCol!.getTag(DG.TAGS.UNITS)}", ` +
       `cell.renderer="${srcSeqCol!.getTag(DG.TAGS.CELL_RENDERER)}"`);
     expect(srcSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
-    expect(srcSeqCol.getTag(DG.TAGS.UNITS), bio.NOTATION.FASTA);
-    expect(srcSeqCol.getTag(bio.TAGS.aligned), bio.ALIGNMENT.SEQ);
-    expect(srcSeqCol.getTag(bio.TAGS.alphabet), bio.ALPHABET.PT);
+    expect(srcSeqCol.getTag(DG.TAGS.UNITS), NOTATION.FASTA);
+    expect(srcSeqCol.getTag(bioTAGS.aligned), ALIGNMENT.SEQ);
+    expect(srcSeqCol.getTag(bioTAGS.alphabet), ALPHABET.PT);
     expect(srcSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
-    const msaSeqCol: DG.Column = (await multipleSequenceAlignmentAny(df, srcSeqCol!))!;
+    const msaSeqCol = multipleSequenceAlignmentAny(srcSeqCol);
     tv.grid.invalidate();
 
-    expect(msaSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
-    expect(msaSeqCol.getTag(DG.TAGS.UNITS), bio.NOTATION.FASTA);
-    expect(msaSeqCol.getTag(bio.TAGS.aligned), bio.ALIGNMENT.SEQ_MSA);
-    expect(msaSeqCol.getTag(bio.TAGS.alphabet), bio.ALPHABET.PT);
-    expect(msaSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
+    // expect(msaSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
+    // expect(msaSeqCol.getTag(DG.TAGS.UNITS), NOTATION.FASTA);
+    // expect(msaSeqCol.getTag(bioTAGS.aligned), ALIGNMENT.SEQ_MSA);
+    // expect(msaSeqCol.getTag(bioTAGS.alphabet), ALPHABET.PT);
+    // expect(msaSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
     // check newColumn with UnitsHandler constructor
-    const uh: bio.UnitsHandler = new bio.UnitsHandler(msaSeqCol);
+    // const uh: UnitsHandler = new UnitsHandler(msaSeqCol);
 
     dfList.push(df);
     tvList.push(tv);
@@ -175,13 +177,13 @@ category('renderers', () => {
     tvList.push(tv);
     dfList.push(df);
 
-    const tgtCol: DG.Column = await convertDo(srcCol, bio.NOTATION.SEPARATOR, '/');
+    const tgtCol: DG.Column = await convertDo(srcCol, NOTATION.SEPARATOR, '/');
 
     const resCellRenderer = tgtCol.getTag(DG.TAGS.CELL_RENDERER);
     expect(resCellRenderer, 'sequence');
 
     // check tgtCol with UnitsHandler constructor
-    const uh: bio.UnitsHandler = new bio.UnitsHandler(tgtCol);
+    const uh: UnitsHandler = new UnitsHandler(tgtCol);
   }
 
   async function _selectRendererBySemType() {
@@ -190,9 +192,9 @@ category('renderers', () => {
     /**/
     const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
       ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
-    seqDiffCol.tags[DG.TAGS.UNITS] = bio.NOTATION.SEPARATOR;
-    seqDiffCol.tags[TAGS.SEPARATOR] = '/';
-    seqDiffCol.semType = SEM_TYPES.MACROMOLECULE_DIFFERENCE;
+    seqDiffCol.tags[DG.TAGS.UNITS] = NOTATION.SEPARATOR;
+    seqDiffCol.tags[bioTAGS.separator] = '/';
+    seqDiffCol.semType = C.SEM_TYPES.MACROMOLECULE_DIFFERENCE;
     const df = DG.DataFrame.fromColumns([seqDiffCol]);
     const tv = grok.shell.addTableView(df);
     dfList.push(df);
@@ -200,10 +202,11 @@ category('renderers', () => {
 
     await delay(100);
     const renderer = seqDiffCol.getTag(DG.TAGS.CELL_RENDERER);
-    if (renderer !== 'MacromoleculeDifference') // this is value of MacromoleculeDifferenceCR.cellType
+    if (renderer !== 'MacromoleculeDifference') { // this is value of MacromoleculeDifferenceCR.cellType
       throw new Error(`Units 'separator', separator '/' and semType 'MacromoleculeDifference' ` +
         `have been manually set on column but after df was added as table, ` +
         `view renderer has set to '${renderer}' instead of correct 'MacromoleculeDifference'.`);
+    }
   }
 
   /** GROK-11212 Do not overwrite / recalculate 'cell.renderer' tag that has been set programmatically
@@ -211,9 +214,9 @@ category('renderers', () => {
   async function _setRendererManually() {
     const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
       ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
-    seqDiffCol.tags[DG.TAGS.UNITS] = bio.NOTATION.SEPARATOR;
-    seqDiffCol.tags[TAGS.SEPARATOR] = '/';
-    seqDiffCol.semType = SEM_TYPES.MACROMOLECULE;
+    seqDiffCol.tags[DG.TAGS.UNITS] = NOTATION.SEPARATOR;
+    seqDiffCol.tags[bioTAGS.separator] = '/';
+    seqDiffCol.semType = DG.SEMTYPE.MACROMOLECULE;
     const tgtCellRenderer = 'MacromoleculeDifference';
     seqDiffCol.setTag(DG.TAGS.CELL_RENDERER, tgtCellRenderer);
     const df = DG.DataFrame.fromColumns([seqDiffCol]);
@@ -224,9 +227,10 @@ category('renderers', () => {
 
     await delay(100);
     const resCellRenderer = seqDiffCol.getTag(DG.TAGS.CELL_RENDERER);
-    if (resCellRenderer !== tgtCellRenderer) // this is value of MacromoleculeDifferenceCR.cellType
+    if (resCellRenderer !== tgtCellRenderer) { // this is value of MacromoleculeDifferenceCR.cellType
       throw new Error(`Tag 'cell.renderer' has been manually set to '${tgtCellRenderer}' for column ` +
         `but after df was added as table, tag 'cell.renderer' has reset to '${resCellRenderer}' ` +
         `instead of manual '${tgtCellRenderer}'.`);
+    }
   }
 });

package/src/tests/sequence-space-test.ts

@@ -1,7 +1,9 @@
-import {after, before, category, test, expect, delay} from '@datagrok-libraries/utils/src/test';
+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, expect, delay} from '@datagrok-libraries/utils/src/test';
 import {readDataframe} from './utils';
-import * as grok from 'datagrok-api/grok';
 import {_testSequenceSpaceReturnsResult} from './sequence-space-utils';
 
 category('sequenceSpace', async () => {
@@ -16,7 +18,7 @@ category('sequenceSpace', async () => {
     await _testSequenceSpaceReturnsResult(testFastaDf, 'UMAP', 'MSA');
     grok.shell.closeTable(testFastaDf);
     testFastaTableView.close();
-  });
+  }, {skipReason: 'GROK-12775'});
 
   test('sequenceSpaceWithEmptyRows', async () => {
     testHelmWithEmptyRows = await readDataframe('tests/sample_MSA_data_empty_vals.csv');
@@ -24,5 +26,5 @@ category('sequenceSpace', async () => {
     await _testSequenceSpaceReturnsResult(testHelmWithEmptyRows, 'UMAP', 'MSA');
     grok.shell.closeTable(testHelmWithEmptyRows);
     testHelmWithEmptyRowsTableView.close();
-  });
+  }, {skipReason: 'GROK-12775'});
 });

package/src/tests/similarity-diversity-tests.ts

@@ -31,9 +31,9 @@ category('similarity/diversity', async () => {
 
 async function _testSimilaritySearchViewer() {
   const molecules = await createTableView('tests/sample_MSA_data.csv');
-  const viewer = molecules.addViewer('SequenceSimilaritySearchViewer');
+  const viewer = molecules.addViewer('Sequence Similarity Search');
   await delay(100);
-  const similaritySearchViewer = getSearchViewer(viewer, 'SequenceSimilaritySearchViewer');
+  const similaritySearchViewer = getSearchViewer(viewer, 'Sequence Similarity Search');
   viewList.push(similaritySearchViewer);
   viewList.push(molecules);
   if (!similaritySearchViewer.molCol)
@@ -59,9 +59,9 @@ async function _testSimilaritySearchViewer() {
 
 async function _testDiversitySearchViewer() {
   const molecules = await createTableView('tests/sample_MSA_data.csv');
-  const viewer = molecules.addViewer('SequenceDiversitySearchViewer');
+  const viewer = molecules.addViewer('Sequence Diversity Search');
   await delay(10);
-  const diversitySearchviewer = getSearchViewer(viewer, 'SequenceDiversitySearchViewer');
+  const diversitySearchviewer = getSearchViewer(viewer, 'Sequence Diversity Search');
   viewList.push(diversitySearchviewer);
   viewList.push(molecules);
   if (!diversitySearchviewer.renderMolIds)

package/src/tests/splitters-test.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, expectObject} from '@datagrok-libraries/utils/src/test';
 import * as C from '../utils/constants';
 import {splitToMonomers, _package, getHelmMonomers} from '../package';
 import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
+import {TAGS as bioTAGS, splitterAsFasta, splitterAsHelm} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 
 category('splitters', () => {
@@ -83,7 +83,7 @@ category('splitters', () => {
     const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
     if (semType)
       seqCol.semType = semType;
-    seqCol.setTag(C.TAGS.ALIGNED, C.MSA);
+    seqCol.setTag(bioTAGS.aligned, C.MSA);
 
     const tv: DG.TableView = grok.shell.addTableView(df);
     // call to calculate 'cell.renderer' tag
@@ -92,9 +92,9 @@ category('splitters', () => {
     dfList.push(df);
     tvList.push(tv);
 
-    splitToMonomers(seqCol);
+    splitToMonomers();
     expect(df.columns.names().includes('17'), true);
-  });
+  }, {skipReason: 'GROK-12766'});
 
   test('getHelmMonomers', async () => {
     const df: DG.DataFrame = DG.DataFrame.fromCsv(
@@ -122,14 +122,13 @@ PEPTIDE1{hHis.Aca.Cys_SEt}$$$,5.72388
 });
 
 export async function _testFastaSplitter(src: string, tgt: string[]) {
-  const res: string[] = bio.splitterAsFasta(src);
+  const res: string[] = splitterAsFasta(src);
   console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(res)} .`);
   expectArray(res, tgt);
 }
 
 export async function _testHelmSplitter(src: string, tgt: string[]) {
-  const res: string[] = bio.splitterAsHelm(src);
+  const res: string[] = splitterAsHelm(src);
   console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(res)} .`);
   expectArray(res, tgt);
 }
-

package/src/tests/substructure-filters-tests.ts

@@ -1,11 +1,33 @@
 import {after, before, category, test, expect, delay} from '@datagrok-libraries/utils/src/test';
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+
 import {readDataframe} from './utils';
 import {BioSubstructureFilter, HelmFilter, SeparatorFilter} from '../widgets/bio-substructure-filter';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {LIB_DEFAULT, LIB_STORAGE_NAME} from '../utils/monomer-lib';
 
 
 category('substructureFilters', async () => {
+  let monomerLibHelper: IMonomerLibHelper;
+  /** Backup actual user's monomer libraries settings */
+  let userLibrariesSettings: {};
+
+  before(async () => {
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibrariesSettings = await grok.dapi.userDataStorage.get(LIB_STORAGE_NAME, true);
+
+    // Test 'helm' requires default monomer library loaded
+    await grok.dapi.userDataStorage.post(LIB_STORAGE_NAME, LIB_DEFAULT, true);
+    await monomerLibHelper.loadLibraries(true); // load default libraries
+  });
+
+  after(async () => {
+    // UserDataStorage.put() replaces existing data
+    await grok.dapi.userDataStorage.put(LIB_STORAGE_NAME, userLibrariesSettings, true);
+    await monomerLibHelper.loadLibraries(true); // load user settings libraries
+  });
+
   test('fasta', async () => {
     const fasta = await readDataframe('tests/filter_FASTA.csv');
     const filter = new BioSubstructureFilter();
@@ -69,5 +91,5 @@ category('substructureFilters', async () => {
     expect(filter.dataFrame!.filter.trueCount, 1);
     expect(filter.dataFrame!.filter.get(3), true);
     helmTableView.close();
-  }, {skipReason: '#1206'});
+  }, {skipReason: 'GROK-12779'});
 });

package/src/tests/utils/sequences-generators.ts

@@ -1,18 +1,18 @@
 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 {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 
 export function generateManySequences(): DG.Column[] {
-  let columns: DG.Column[] = [];
+  const columns: DG.Column[] = [];
   columns.push(DG.Column.fromList('string', 'MSA', new Array(10 ** 6).fill('meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me')));
   columns.push(DG.Column.fromList('string', 'Activity', new Array(10 ** 6).fill('5.30751')));
   return columns;
 }
 
 export function generateLongSequence(): DG.Column[] {
-  let columns: DG.Column[] = [];
+  const columns: DG.Column[] = [];
   const longSequence = `meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr`.repeat(10 ** 5);
   columns.push(DG.Column.fromList('string', 'MSA', new Array(10 ** 2).fill(longSequence)));
   columns.push(DG.Column.fromList('string', 'Activity', new Array(10 ** 2).fill('7.30751')));
@@ -21,10 +21,10 @@ export function generateLongSequence(): DG.Column[] {
 
 export function setTagsMacromolecule(col: DG.Column) {
   col.semType = DG.SEMTYPE.MACROMOLECULE;
-  col.setTag(DG.TAGS.UNITS, bio.NOTATION.SEPARATOR);
-  col.setTag(bio.TAGS.aligned, bio.ALIGNMENT.SEQ_MSA);
-  col.setTag(bio.TAGS.alphabet, bio.ALPHABET.UN);
-  col.setTag(bio.TAGS.separator, '/');
+  col.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
+  col.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
+  col.setTag(bioTAGS.alphabet, ALPHABET.UN);
+  col.setTag(bioTAGS.separator, '/');
   return col;
 }
 

package/src/tests/utils.ts

@@ -1,8 +1,9 @@
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+
+import {_package} from '../package-test';
 import {expect} from '@datagrok-libraries/utils/src/test';
 import {runKalign} from '../utils/multiple-sequence-alignment';
-import {_package} from '../package-test';
 
 export async function loadFileAsText(name: string): Promise<string> {
   return await _package.files.readAsText(name);

package/src/tests/viewers.ts

@@ -0,0 +1,16 @@
+import * as DG from 'datagrok-api/dg';
+// import * as grok from 'datagrok-api/grok';
+//import * as ui from 'datagrok-api/ui';
+
+import {category, test, testViewer} from '@datagrok-libraries/utils/src/test';
+import {readDataframe} from './utils';
+
+
+category('viewers', () => {
+  const viewers = DG.Func.find({package: 'Bio', tags: ['viewer']}).map((f) => f.friendlyName);
+  for (const v of viewers) {
+    test(v, async () => {
+      await testViewer(v, await readDataframe('data/sample_FASTA_DNA.csv'), true);
+    });
+  }
+});