@datagrok/bio 2.1.12 → 2.4.2

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

@@ -1,16 +1,15 @@
 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, 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 {
-  ALPHABET,
-  NOTATION,
-  PositionInfo,
-  PositionMonomerInfo,
-  TAGS as bioTAGS,
+  countForMonomerAtPosition,
+  FilterSources,
+  PositionInfo as PI,
+  PositionMonomerInfo as PMI,
   WebLogoViewer
-} from '@datagrok-libraries/bio';
+} from '../viewers/web-logo-viewer';
 
 category('WebLogo-positions', () => {
   let tvList: DG.TableView[];
@@ -28,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 () => {
@@ -53,21 +53,21 @@ ATC-G-TTGC--
     tvList.push(tv);
     dfList.push(df);
 
-    const positions: PositionInfo[] = wlViewer['positions'];
-
-    const resAllDf1: PositionInfo[] = [
-      new PositionInfo('1', {'A': new PositionMonomerInfo(2), '-': new PositionMonomerInfo(3)}),
-      new PositionInfo('2', {'T': new PositionMonomerInfo(5)}),
-      new PositionInfo('3', {'C': new PositionMonomerInfo(5)}),
-      new PositionInfo('4', {'-': new PositionMonomerInfo(5)}),
-      new PositionInfo('5', {'G': new PositionMonomerInfo(5)}),
-      new PositionInfo('6', {'-': new PositionMonomerInfo(3), 'C': new PositionMonomerInfo(2)}),
-      new PositionInfo('7', {'T': new PositionMonomerInfo(5)}),
-      new PositionInfo('8', {'T': new PositionMonomerInfo(5)}),
-      new PositionInfo('9', {'G': new PositionMonomerInfo(5)}),
-      new PositionInfo('10', {'C': new PositionMonomerInfo(5)}),
-      new PositionInfo('11', {'-': new PositionMonomerInfo(5)}),
-      new PositionInfo('12', {'-': new 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);
@@ -108,18 +108,18 @@ ATC-G-TTGC--
     tvList.push(tv);
     dfList.push(df);
 
-    const positions: PositionInfo[] = wlViewer['positions'];
-
-    const resAllDf1: PositionInfo[] = [
-      new PositionInfo('1', {'-': new PositionMonomerInfo(3)}),
-      new PositionInfo('2', {'T': new PositionMonomerInfo(3)}),
-      new PositionInfo('3', {'-': new PositionMonomerInfo(3)}),
-      new PositionInfo('4', {'-': new PositionMonomerInfo(3)}),
-      new PositionInfo('5', {'C': new PositionMonomerInfo(3)}),
-      new PositionInfo('6', {'-': new PositionMonomerInfo(2), 'C': new PositionMonomerInfo(1)}),
-      new PositionInfo('7', {'G': new PositionMonomerInfo(3)}),
-      new PositionInfo('8', {'T': new PositionMonomerInfo(3)}),
-      new PositionInfo('9', {'-': new 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);
@@ -149,27 +149,83 @@ ATC-G-TTGC--
     tvList.push(tv);
     dfList.push(df);
 
-    const positions: PositionInfo[] = wlViewer['positions'];
-
-    const resAllDf1: PositionInfo[] = [
-      new PositionInfo('1', {'A': new PositionMonomerInfo(2), '-': new PositionMonomerInfo(3)}),
-      new PositionInfo('2', {'T': new PositionMonomerInfo(5)}),
-      new PositionInfo('3', {'C': new PositionMonomerInfo(5)}),
-      new PositionInfo('5', {'G': new PositionMonomerInfo(5)}),
-      new PositionInfo('6', {'-': new PositionMonomerInfo(3), 'C': new PositionMonomerInfo(2)}),
-      new PositionInfo('7', {'T': new PositionMonomerInfo(5)}),
-      new PositionInfo('8', {'T': new PositionMonomerInfo(5)}),
-      new PositionInfo('9', {'G': new PositionMonomerInfo(5)}),
-      new PositionInfo('10', {'C': new 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

@@ -4,17 +4,16 @@ import * as DG from 'datagrok-api/dg';
 
 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';
+} 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

package/src/tests/checkInputColumn-tests.ts

@@ -6,7 +6,7 @@ import * as DG from 'datagrok-api/dg';
 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';
+import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 category('checkInputColumn', () => {
   const csv = `seq

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 {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
 
 import {ConverterFunc} from './types';
-import {NOTATION, NotationConverter, UnitsHandler} from '@datagrok-libraries/bio';
+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,23 +135,17 @@ 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: NOTATION, tgtSeparator: string | null = null): ConverterFunc {
     if (tgtNotation === NOTATION.SEPARATOR && !tgtSeparator)
@@ -142,9 +157,9 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
       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');
 
@@ -173,6 +188,9 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
   test('testFastaGapsToSeparator', async () => {
     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 () => {
@@ -187,6 +205,10 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
   test('testFastaGapsToHelm', async () => {
     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
@@ -203,6 +225,9 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
   test('testSeparatorGapsToFasta', async () => {
     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 () => {
@@ -217,6 +242,10 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
   test('testSeparatorGapsToHelm', async () => {
     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
@@ -230,6 +259,9 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
   test('testHelmPtToFasta', async () => {
     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 () => {
@@ -241,6 +273,9 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
   test('testHelmPtToSeparator', async () => {
     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 () => {

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

@@ -3,8 +3,9 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
-import {ALPHABET, getAlphabet, NOTATION, 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', () => {
 
@@ -40,7 +41,7 @@ category('detectorsBenchmark', () => {
 
   test('separatorDnaShorts50Few50', async () => {
     const et: number = await detectMacromoleculeBenchmark(10, NOTATION.SEPARATOR, ALPHABET.DNA, 50, 50, '/');
-  });
+  }, {skipReason: '#1192'});
 
   test('separatorDnaShorts50Many1E6', async () => {
       const et: number = await detectMacromoleculeBenchmark(10, NOTATION.SEPARATOR, ALPHABET.DNA, 50, 1E6, '/');