@datagrok/bio 2.4.31 → 2.4.40

package/src/tests/renderers-test.ts

@@ -7,7 +7,6 @@ import {importFasta} from '../package';
 import {convertDo} from '../utils/convert';
 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';
 import {multipleSequenceAlignmentUI} from '../utils/multiple-sequence-alignment-ui';
@@ -29,35 +28,38 @@ category('renderers', () => {
 
   test('long sequence performance ', async () => {
     performanceTest(generateLongSequence, 'Long sequences');
-  });
+  }, {skipReason: 'GROK-13300'});
 
   test('many sequence performance', async () => {
     performanceTest(generateManySequences, 'Many sequences');
-  });
+  }, {skipReason: 'GROK-13300'});
+  test('many sequence performance', async () => {
+    performanceTest(generateManySequences, 'Many sequences');
+  }, {skipReason: 'GROK-13300'});
 
   test('rendererMacromoleculeFasta', async () => {
     await _rendererMacromoleculeFasta();
-  });
+  }, {skipReason: 'GROK-13300'});
 
   test('rendererMacromoleculeSeparator', async () => {
     await _rendererMacromoleculeSeparator();
-  });
+  }, {skipReason: 'GROK-13300'});
 
   test('rendererMacromoleculeDifference', async () => {
     await _rendererMacromoleculeDifference();
-  });
+  }, {skipReason: 'GROK-13300'});
 
   test('afterMsa', async () => {
     await _testAfterMsa();
-  });
+  }, {skipReason: 'GROK-13300'});
 
   test('afterConvert', async () => {
     await _testAfterConvert();
-  });
+  }, {skipReason: 'GROK-13300'});
 
   test('selectRendererBySemType', async () => {
     await _selectRendererBySemType();
-  });
+  }, {skipReason: 'GROK-13300'});
 
   test('setRendererManually', async () => {
     await _setRendererManually();
@@ -156,7 +158,7 @@ category('renderers', () => {
     expect(msaSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
     // check newColumn with UnitsHandler constructor
-    const uh: UnitsHandler = new UnitsHandler(msaSeqCol);
+    const _uh: UnitsHandler = UnitsHandler.getOrCreate(msaSeqCol);
 
     dfList.push(df);
     tvList.push(tv);
@@ -184,7 +186,7 @@ category('renderers', () => {
     expect(resCellRenderer, 'sequence');
 
     // check tgtCol with UnitsHandler constructor
-    const uh: UnitsHandler = new UnitsHandler(tgtCol);
+    const _uh: UnitsHandler = UnitsHandler.getOrCreate(tgtCol);
   }
 
   async function _selectRendererBySemType() {

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

@@ -2,10 +2,10 @@ 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 {category, test} from '@datagrok-libraries/utils/src/test';
 import {readDataframe} from './utils';
 import {_testSequenceSpaceReturnsResult} from './sequence-space-utils';
-import { DimReductionMethods } from '@datagrok-libraries/ml/src/reduce-dimensionality';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 
 category('sequenceSpace', async () => {
   let testFastaDf: DG.DataFrame;
@@ -14,18 +14,20 @@ category('sequenceSpace', async () => {
   let testHelmWithEmptyRowsTableView: DG.TableView;
 
   test('sequenceSpaceOpens', async () => {
-    testFastaDf = await readDataframe('tests/sample_MSA_data.csv');
+    testFastaDf = await readDataframe(
+      DG.Test.isInBenchmark ? 'test/peptides_motif-with-random_10000.csv' : 'tests/100_3_clustests.csv',
+    );
     testFastaTableView = grok.shell.addTableView(testFastaDf);
-    await _testSequenceSpaceReturnsResult(testFastaDf, DimReductionMethods.UMAP, 'MSA');
+    await _testSequenceSpaceReturnsResult(testFastaDf, DimReductionMethods.UMAP, 'sequence');
     grok.shell.closeTable(testFastaDf);
     testFastaTableView.close();
-  }, {skipReason: 'GROK-12775'});
+  });
 
   test('sequenceSpaceWithEmptyRows', async () => {
-    testHelmWithEmptyRows = await readDataframe('tests/sample_MSA_data_empty_vals.csv');
+    testHelmWithEmptyRows = await readDataframe('tests/100_3_clustests_empty_vals.csv');
     testHelmWithEmptyRowsTableView = grok.shell.addTableView(testHelmWithEmptyRows);
-    await _testSequenceSpaceReturnsResult(testHelmWithEmptyRows, DimReductionMethods.UMAP, 'MSA');
+    await _testSequenceSpaceReturnsResult(testHelmWithEmptyRows, DimReductionMethods.UMAP, 'sequence');
     grok.shell.closeTable(testHelmWithEmptyRows);
     testHelmWithEmptyRowsTableView.close();
-  }, {skipReason: 'GROK-12775'});
+  });
 });

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

@@ -2,10 +2,12 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 import {expect} from '@datagrok-libraries/utils/src/test';
 import {sequenceSpaceTopMenu} from '../package';
-import { MmDistanceFunctionsNames } from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
-import { DimReductionMethods } from '@datagrok-libraries/ml/src/reduce-dimensionality';
+import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 
-export async function _testSequenceSpaceReturnsResult(df: DG.DataFrame, algorithm: DimReductionMethods, colName: string) {
+export async function _testSequenceSpaceReturnsResult(
+  df: DG.DataFrame, algorithm: DimReductionMethods, colName: string,
+) {
   // await grok.data.detectSemanticTypes(df);
   const col: DG.Column = df.getCol(colName);
   const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: col});
@@ -14,4 +16,4 @@ export async function _testSequenceSpaceReturnsResult(df: DG.DataFrame, algorith
 
   const sp = await sequenceSpaceTopMenu(df, df.col(colName)!, algorithm, MmDistanceFunctionsNames.LEVENSHTEIN, true);
   expect(sp != null, true);
-}
+}

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

@@ -1,75 +1,73 @@
-import {after, before, category, test, expect, delay} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, test, expect, awaitCheck} from '@datagrok-libraries/utils/src/test';
 import * as DG from 'datagrok-api/dg';
-import {createTableView, readDataframe} from './utils';
+import {createTableView} from './utils';
 import * as grok from 'datagrok-api/grok';
 import {SequenceSimilarityViewer} from '../analysis/sequence-similarity-viewer';
 
-let viewList: DG.ViewBase[];
-let dfList: DG.DataFrame[];
-
-
 category('similarity/diversity', async () => {
-
   before(async () => {
-    viewList = [];
-    dfList = [];
+    // grok.shell.closeAll();
   });
 
   after(async () => {
-    for (const view of viewList) view.close();
-    for (const df of dfList) grok.shell.closeTable(df);
+    grok.shell.closeAll();
   });
 
-
   test('similaritySearchViewer', async () => {
     await _testSimilaritySearchViewer();
   });
+
   test('diversitySearchViewer', async () => {
     await _testDiversitySearchViewer();
   });
 });
 
 async function _testSimilaritySearchViewer() {
-  const molecules = await createTableView('tests/sample_MSA_data.csv');
-  const viewer = molecules.addViewer('Sequence Similarity Search');
-  await delay(100);
-  const similaritySearchViewer = getSearchViewer(viewer, 'Sequence Similarity Search');
-  viewList.push(similaritySearchViewer);
-  viewList.push(molecules);
-  if (!similaritySearchViewer.molCol)
-    await waitForCompute(similaritySearchViewer);
-  expect(similaritySearchViewer.fingerprint, 'Morgan');
-  expect(similaritySearchViewer.distanceMetric, 'Tanimoto');
-  expect(similaritySearchViewer.scores!.get(0), DG.FLOAT_NULL);
-  expect(similaritySearchViewer.idxs!.get(0), 0);
-  expect(similaritySearchViewer.molCol!.get(0),
-    'D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me');
-  expect(similaritySearchViewer.scores!.get(1), 0.4722222089767456);
-  expect(similaritySearchViewer.idxs!.get(1), 11);
-  expect(similaritySearchViewer.molCol!.get(1),
-    'meI/hHis//Aca/meM/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me');
-  const waiter = waitForCompute(similaritySearchViewer); /* subscribe for computeCompleted event before start compute */
-  molecules.dataFrame.currentRowIdx = 1;
-  await waiter;
-  expect(similaritySearchViewer.targetMoleculeIdx, 1);
-  expect(similaritySearchViewer.molCol!.get(0),
-    'meI/hHis/Aca/Cys_SEt/T/dK/Thr_PO3H2/Aca/Tyr_PO3H2/D-Chg/dV/Phe_ab-dehydro/N/D-Orn/D-aThr//Phe_4Me');
-}
+  try {
+    const molecules = await createTableView('tests/sample_MSA_data.csv');
+    const viewer = molecules.addViewer('Sequence Similarity Search');
+    await awaitCheck(() => getSearchViewer(viewer, 'Sequence Similarity Search') !== undefined,
+      'Sequence Similarity Search has not been created', 5000);
+    const similaritySearchViewer: SequenceSimilarityViewer = getSearchViewer(viewer, 'Sequence Similarity Search');
+    await awaitCheck(() => similaritySearchViewer.root.getElementsByClassName('d4-grid').length !== 0,
+      'Sequence Similarity Search has not been created', 5000);
+    expect(similaritySearchViewer.fingerprint, 'Morgan');
+    expect(similaritySearchViewer.distanceMetric, 'Tanimoto');
+    expect(similaritySearchViewer.scores!.get(0), DG.FLOAT_NULL);
+    expect(similaritySearchViewer.idxs!.get(0), 0);
+    expect(similaritySearchViewer.molCol!.get(0),
+      'D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me');
+    expect(similaritySearchViewer.scores!.get(1), 0.4722222089767456);
+    expect(similaritySearchViewer.idxs!.get(1), 11);
+    expect(similaritySearchViewer.molCol!.get(1),
+      'meI/hHis//Aca/meM/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me');
+    molecules.dataFrame.currentRowIdx = 1;
+    await awaitCheck(() => similaritySearchViewer.targetMoleculeIdx === 1, 'Target molecule has not been changed', 5000);
+    await awaitCheck(() => similaritySearchViewer.molCol!.get(0) ===
+        'meI/hHis/Aca/Cys_SEt/T/dK/Thr_PO3H2/Aca/Tyr_PO3H2/D-Chg/dV/Phe_ab-dehydro/N/D-Orn/D-aThr//Phe_4Me',
+      'Incorrect first similar molecule', 5000);
 
+  } finally {
+    grok.shell.closeAll();
+  }
+}
 
 async function _testDiversitySearchViewer() {
-  const molecules = await createTableView('tests/sample_MSA_data.csv');
-  const viewer = molecules.addViewer('Sequence Diversity Search');
-  await delay(10);
-  const diversitySearchviewer = getSearchViewer(viewer, 'Sequence Diversity Search');
-  viewList.push(diversitySearchviewer);
-  viewList.push(molecules);
-  if (!diversitySearchviewer.renderMolIds)
-    await waitForCompute(diversitySearchviewer);
-  expect(diversitySearchviewer.fingerprint, 'Morgan');
-  expect(diversitySearchviewer.distanceMetric, 'Tanimoto');
-  expect(diversitySearchviewer.initialized, true);
-  expect(diversitySearchviewer.renderMolIds.length > 0, true);
+  try {
+    const molecules = await createTableView('tests/sample_MSA_data.csv');
+    const viewer = molecules.addViewer('Sequence Diversity Search');
+    await awaitCheck(() => getSearchViewer(viewer, 'Sequence Diversity Search') !== undefined,
+      'Sequence Diversity Search has not been created', 5000);
+    const diversitySearchviewer = getSearchViewer(viewer, 'Sequence Diversity Search');
+    await awaitCheck(() => diversitySearchviewer.root.getElementsByClassName('d4-grid').length !== 0,
+      'Sequence Diversity Search has not been created', 5000);
+    expect(diversitySearchviewer.fingerprint, 'Morgan');
+    expect(diversitySearchviewer.distanceMetric, 'Tanimoto');
+    expect(diversitySearchviewer.initialized, true);
+    expect(diversitySearchviewer.renderMolIds.length > 0, true);
+  } finally {
+    grok.shell.closeAll();
+  }
 }
 
 function getSearchViewer(viewer: DG.Viewer, name: string) {
@@ -80,15 +78,3 @@ function getSearchViewer(viewer: DG.Viewer, name: string) {
   }
 }
 
-async function waitForCompute(viewer: SequenceSimilarityViewer) {
-  const t = new Promise((resolve, reject) => {
-    viewer.computeCompleted.subscribe(async (_: any) => {
-      try {
-        resolve(true);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  });
-  await t;
-}

package/src/tests/splitters-test.ts

@@ -2,66 +2,58 @@ 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, expectArray, expectObject, delay} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, test, expect, expectArray, delay} from '@datagrok-libraries/utils/src/test';
 import * as C from '../utils/constants';
 import {_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', () => {
-  let tvList: DG.TableView[];
-  let dfList: DG.DataFrame[];
-
+category('splitters', async () => {
   before(async () => {
-    tvList = [];
-    dfList = [];
   });
 
   after(async () => {
-    dfList.forEach((df: DG.DataFrame) => { grok.shell.closeTable(df); });
-    tvList.forEach((tv: DG.TableView) => tv.close());
   });
 
-  const helm1 = 'PEPTIDE1{meI.hHis.Aca.N.T.dE.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$';
+  const _helm1 = 'PEPTIDE1{meI.hHis.Aca.N.T.dE.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$';
 
-  const helm2 = 'PEPTIDE1{meI.hHis.Hcy.Q.T.W.Q.Phe_4NH2.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.N.meK}$$$';
+  const _helm2 = 'PEPTIDE1{meI.hHis.Hcy.Q.T.W.Q.Phe_4NH2.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.N.meK}$$$';
 
   const data: { [key: string]: [string, string[]] } = {
     fastaMulti: [
       'M[MeI]YKETLL[MeF]PKTDFPMRGGL[MeA]',
       ['M', 'MeI', 'Y', 'K', 'E', 'T', 'L', 'L', 'MeF', 'P',
-        'K', 'T', 'D', 'F', 'P', 'M', 'R', 'G', 'G', 'L', 'MeA']
+        'K', 'T', 'D', 'F', 'P', 'M', 'R', 'G', 'G', 'L', 'MeA'],
     ],
     helm1: [
       'PEPTIDE1{meI.hHis.Aca.N.T.dE.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$',
       ['meI', 'hHis', 'Aca', 'N', 'T', 'dE', 'Thr_PO3H2', 'Aca', 'D-Tyr_Et',
-        'Tyr_ab-dehydroMe', 'dV', 'E', 'N', 'D-Orn', 'D-aThr', 'Phe_4Me']
+        'Tyr_ab-dehydroMe', 'dV', 'E', 'N', 'D-Orn', 'D-aThr', 'Phe_4Me'],
     ],
     helm2: [
       'PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2.Aca.D-Tyr_Et.D-Dap.dV.E.N.pnG.Phe_4Me}$$$',
       ['meI', 'hHis', 'Aca', 'N', 'T', 'dK', 'Thr_PO3H2', 'Aca',
-        'D-Tyr_Et', 'D-Dap', 'dV', 'E', 'N', 'pnG', 'Phe_4Me']
+        'D-Tyr_Et', 'D-Dap', 'dV', 'E', 'N', 'pnG', 'Phe_4Me'],
     ],
     // HELM editor dialog returns HELM string with multichar monomer names in square brackets
     helm3: [
       'PEPTIDE1{[meI].[hHis].[Aca].N.T.[dK].[Thr_PO3H2].[Aca].[D-Tyr_Et].[D-Dap].[dV].E.N.[pnG].[Phe_4Me]}$$$',
       ['meI', 'hHis', 'Aca', 'N', 'T', 'dK', 'Thr_PO3H2', 'Aca',
-        'D-Tyr_Et', 'D-Dap', 'dV', 'E', 'N', 'pnG', 'Phe_4Me']
+        'D-Tyr_Et', 'D-Dap', 'dV', 'E', 'N', 'pnG', 'Phe_4Me'],
     ],
 
     testHelm1: [
       'RNA1{R(U)P.R(T)P.R(G)P.R(C)P.R(A)}$$$$',
-      ['R(U)P', 'R(T)P', 'R(G)P', 'R(C)P', 'R(A)']
+      ['R(U)P', 'R(T)P', 'R(G)P', 'R(C)P', 'R(A)'],
     ],
 
     testHelm2: [
       'RNA1{P.R(U)P.R(T)}$$$$',
-      ['P', 'R(U)P', 'R(T)']
+      ['P', 'R(U)P', 'R(T)'],
     ],
     testHelm3: [
       'RNA1{P.R(U).P.R(T)}$$$$',
-      ['P', 'R(U)', 'P', 'R(T)']
+      ['P', 'R(U)', 'P', 'R(T)'],
     ],
   };
 
@@ -85,7 +77,8 @@ category('splitters', () => {
       seqCol.semType = semType;
     seqCol.setTag(bioTAGS.aligned, C.MSA);
 
-    const tv: DG.TableView = grok.shell.addTableView(df);
+    const _tv: DG.TableView = grok.shell.addTableView(df);
+    await delay(500); // needed to account for table adding
     // call to calculate 'cell.renderer' tag
     await grok.data.detectSemanticTypes(df);
 
@@ -99,6 +92,7 @@ category('splitters', () => {
 PEPTIDE1{hHis.N.T}$$$,5.30751
 PEPTIDE1{hHis.Aca.Cys_SEt}$$$,5.72388
 `);
+    await grok.data.detectSemanticTypes(df);
     const expectedMonomerList = ['hHis', 'Aca', 'Cys_SEt', 'N', 'T'];
 
     const helmCol: DG.Column = df.getCol('HELM');

package/src/tests/to-atomic-level-tests.ts

@@ -95,44 +95,36 @@ category('toAtomicLevel', async () => {
     [csvTests.fastaDna]: `seq
 ACGTC
 CAGTGT
-TTCAAC
-`,
+TTCAAC`,
     [csvTests.fastaRna]: `seq
 ACGUC
 CAGUGU
-UUCAAC
-`,
+UUCAAC`,
     [csvTests.fastaPt]: `seq
 FWPHEY
 YNRQWYV
-MKPSEYV
-`,
+MKPSEYV`,
     [csvTests.separatorDna]: `seq
 A/C/G/T/C
 C/A/G/T/G/T
-T/T/C/A/A/C
-`,
+T/T/C/A/A/C`,
     [csvTests.separatorRna]: `seq
 A*C*G*U*C
 C*A*G*U*G*U
-U*U*C*A*A*C
-`,
+U*U*C*A*A*C`,
     [csvTests.separatorPt]: `seq
 F-W-P-H-E-Y
 Y-N-R-Q-W-Y-V
-M-K-P-S-E-Y-V
-`,
+M-K-P-S-E-Y-V`,
     [csvTests.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
-`,
+Lys_Boc-hHis-Aca-Cys_SEt-T-dK-Thr_PO3H2-Aca-Tyr_PO3H2`,
 
     [csvTests.helm]: `seq
 PEPTIDE1{meI.D-gGlu.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}$$$
-`,
+PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2}$$$`,
   };
 
   /** Also detects semantic types
@@ -183,5 +175,5 @@ PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2}$$$
 async function _testToAtomicLevel(df: DG.DataFrame, seqColName: string = 'seq', monomerLibHelper: IMonomerLibHelper) {
   const seqCol: DG.Column<string> = df.getCol(seqColName);
   const monomerLib: IMonomerLib = monomerLibHelper.getBioLib();
-  const resCol = await _toAtomicLevel(df, seqCol, monomerLib);
+  const _resCol = await _toAtomicLevel(df, seqCol, monomerLib);
 }

package/src/tests/units-handler-splitted-tests.ts

@@ -0,0 +1,106 @@
+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, expectArray} from '@datagrok-libraries/utils/src/test';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+
+category('UnitsHandler', () => {
+  const data: { [testName: string]: { src: { csv: string }, tgt: { splitted: string[][] } } } = {
+    fasta: {
+      src: {
+        csv: `seq
+ACGTC
+CAGTGT
+TTCAAC`
+      },
+      tgt: {
+        splitted: [
+          ['A', 'C', 'G', 'T', 'C'],
+          ['C', 'A', 'G', 'T', 'G', 'T'],
+          ['T', 'T', 'C', 'A', 'A', 'C']
+        ]
+      }
+    },
+    fastaMsa: {
+      src: {
+        csv: `seq
+AC-GT-CT
+CAC-T-GT
+ACCGTACT`,
+      },
+      tgt: {
+        splitted: [
+          //@formatter:off
+          ['A', 'C', '' , 'G', 'T', '' , 'C', 'T'],
+          ['C', 'A', 'C', '' , 'T', '' , 'G', 'T'],
+          ['A', 'C', 'C', 'G', 'T', 'A', 'C', 'T'],
+          //@formatter:on
+        ]
+      }
+    },
+    separator: {
+      src: {
+        csv: `seq
+abc-dfgg-abc1-cfr3-rty-wert
+rut12-her2-rty-wert-abc-abc1-dfgg
+rut12-rty-her2-abc-cfr3-wert-rut12`,
+      },
+      tgt: {
+        splitted: [
+          ['abc', 'dfgg', 'abc1', 'cfr3', 'rty', 'wert'],
+          ['rut12', 'her2', 'rty', 'wert', 'abc', 'abc1', 'dfgg'],
+          ['rut12', 'rty', 'her2', 'abc', 'cfr3', 'wert', 'rut12']
+        ]
+      }
+    },
+
+    separatorMsa: {
+      src: {
+        csv: `seq
+abc-dfgg-abc1-cfr3-rty-wert
+rut12-her2-rty--abc1-dfgg
+rut12-rty-her2---wert`
+      },
+      tgt: {
+        splitted: [
+          ['abc', 'dfgg', 'abc1', 'cfr3', 'rty', 'wert'],
+          ['rut12', 'her2', 'rty', '', 'abc1', 'dfgg'],
+          ['rut12', 'rty', 'her2', '', '', 'wert'],
+        ]
+      }
+    },
+    helm: {
+      src: {
+        csv: `seq
+PEPTIDE1{meI.hHis.Aca.N.T.dE.Thr_PO3H2.Aca.D-Tyr_Et}$$$$
+PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca}$$$$
+PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca}$$$$
+PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2}$$$$`
+      },
+      tgt: {
+        splitted: [
+          ['meI', 'hHis', 'Aca', 'N', 'T', 'dE', 'Thr_PO3H2', 'Aca', 'D-Tyr_Et'],
+          ['meI', 'hHis', 'Aca', 'Cys_SEt', 'T', 'dK', 'Thr_PO3H2', 'Aca'],
+          ['Lys_Boc', 'hHis', 'Aca', 'Cys_SEt', 'T', 'dK', 'Thr_PO3H2', 'Aca'],
+          ['meI', 'hHis', 'Aca', 'Cys_SEt', 'T', 'dK', 'Thr_PO3H2'],
+        ]
+      }
+    }
+  };
+
+  for (const [testName, testData] of Object.entries(data)) {
+    test(`splitted-${testName}`, async () => {
+      const df: DG.DataFrame = DG.DataFrame.fromCsv(testData.src.csv);
+      const col: DG.Column = df.getCol('seq');
+
+      const semType = await grok.functions.call('Bio:detectMacromolecule', {col: col});
+      if (semType) col.semType = semType;
+      expect(col.semType, DG.SEMTYPE.MACROMOLECULE);
+
+      const uh = UnitsHandler.getOrCreate(col);
+      const splitted: string[][] = uh.splitted;
+      expectArray(splitted, testData.tgt.splitted);
+    });
+  }
+});

package/src/tests/units-handler-tests.ts

@@ -2,75 +2,71 @@ 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} from '@datagrok-libraries/utils/src/test';
+import {category, test, expect} from '@datagrok-libraries/utils/src/test';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {ALPHABET, NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 const seqDna = `seq
 ACGTC
 CAGTGT
-TTCAAC
-`;
+TTCAAC`;
 
 const seqDnaMsa = `seq
 AC-GT-CT
 CAC-T-GT
-ACCGTACT
-`;
+ACCGTACT`;
 
 const seqUn = `seq
 abc-dfgg-abc1-cfr3-rty-wert
 rut12-her2-rty-wert-abc-abc1-dfgg
-rut12-rty-her2-abc-cfr3-wert-rut12
-`;
+rut12-rty-her2-abc-cfr3-wert-rut12`;
 
 const seqHelm = `seq
 PEPTIDE1{meI.hHis.Aca.N.T.dE.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$$
 PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Phe_ab-dehydro.N.D-Orn.D-aThr.Phe_4Me}$$$$
 PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Thr_PO3H2.N.D-Orn.D-aThr.Phe_4Me}$$$$
-PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Thr_PO3H2.N.D-Orn.D-aThr.Phe_4Me}$$$$
-`;
+PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Thr_PO3H2.N.D-Orn.D-aThr.Phe_4Me}$$$$`;
 
-category('UnitsHandler', () =>{
-  test('Seq-Fasta', async () =>{
-    const [df, uh] = await loadCsvWithDetection(seqDna);
+category('UnitsHandler', () => {
+  test('Seq-Fasta', async () => {
+    const [_df, uh] = await loadCsvWithDetection(seqDna);
     expect(uh.notation, NOTATION.FASTA);
     expect(uh.isMsa(), false);
   });
 
-  test('Seq-Fasta-MSA', async () =>{
-    const [df, uh] = await loadCsvWithDetection(seqDnaMsa);
+  test('Seq-Fasta-MSA', async () => {
+    const [_df, uh] = await loadCsvWithDetection(seqDnaMsa);
     expect(uh.notation, NOTATION.FASTA);
     expect(uh.isMsa(), true);
   });
 
-  test('Seq-Fasta-units', async () =>{
-    const [df, uh] = await loadCsvWithTag(seqDna, DG.TAGS.UNITS, NOTATION.FASTA);
+  test('Seq-Fasta-units', async () => {
+    const [_df, uh] = await loadCsvWithTag(seqDna, DG.TAGS.UNITS, NOTATION.FASTA);
     expect(uh.notation, NOTATION.FASTA);
     expect(uh.isMsa(), false);
   });
 
-  test('Seq-Fasta-MSA-units', async () =>{
-    const [df, uh] = await loadCsvWithTag(seqDnaMsa, DG.TAGS.UNITS, NOTATION.FASTA);
+  test('Seq-Fasta-MSA-units', async () => {
+    const [_df, uh] = await loadCsvWithTag(seqDnaMsa, DG.TAGS.UNITS, NOTATION.FASTA);
     expect(uh.notation, NOTATION.FASTA);
     expect(uh.isMsa(), true);
   });
 
-  test('Seq-Helm', async () =>{
-    const [df, uh] = await loadCsvWithTag(seqHelm, DG.TAGS.UNITS, NOTATION.HELM);
+  test('Seq-Helm', async () => {
+    const [_df, uh] = await loadCsvWithTag(seqHelm, DG.TAGS.UNITS, NOTATION.HELM);
     expect(uh.notation, NOTATION.HELM);
     expect(uh.isHelm(), true);
   });
 
-  test('Seq-UN', async () =>{
-    const [df, uh] = await loadCsvWithTag(seqUn, DG.TAGS.UNITS, NOTATION.SEPARATOR);
+  test('Seq-UN', async () => {
+    const [_df, uh] = await loadCsvWithTag(seqUn, DG.TAGS.UNITS, NOTATION.SEPARATOR);
     expect(uh.notation, NOTATION.SEPARATOR);
     expect(uh.separator, '-');
     expect(uh.alphabet, ALPHABET.UN);
   });
 
-  test('Seq-UN-auto', async () =>{
-    const [df, uh] = await loadCsvWithDetection(seqUn);
+  test('Seq-UN-auto', async () => {
+    const [_df, uh] = await loadCsvWithDetection(seqUn);
     expect(uh.notation, NOTATION.SEPARATOR);
     expect(uh.separator, '-');
     expect(uh.alphabet, ALPHABET.UN);
@@ -79,7 +75,7 @@ category('UnitsHandler', () =>{
   async function loadCsvWithDetection(csv: string): Promise<[df: DG.DataFrame, uh: UnitsHandler]> {
     const df = DG.DataFrame.fromCsv(csv);
     await grok.data.detectSemanticTypes(df);
-    const uh = new UnitsHandler(df.getCol('seq'));
+    const uh = UnitsHandler.getOrCreate(df.getCol('seq'));
     return [df, uh];
   }
 
@@ -91,7 +87,7 @@ category('UnitsHandler', () =>{
     col.semType = DG.SEMTYPE.MACROMOLECULE;
     if (value === NOTATION.SEPARATOR)
       col.setTag(TAGS.separator, '-');
-    const uh = new UnitsHandler(df.getCol('seq'));
+    const uh = UnitsHandler.getOrCreate(df.getCol('seq'));
     return [df, uh];
   }
 });