@datagrok/bio 1.10.2 → 1.11.2

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "1.10.2",
+  "version": "1.11.2",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -14,12 +14,12 @@
   },
   "dependencies": {
     "@biowasm/aioli": ">=2.4.0",
-    "@datagrok-libraries/bio": "^4.1.0",
+    "@datagrok-libraries/bio": "^4.2.1",
     "@datagrok-libraries/chem-meta": "1.0.0",
-    "@datagrok-libraries/ml": "^4.0.0",
+    "@datagrok-libraries/ml": "^6.0.0",
     "@datagrok-libraries/utils": "^1.6.2",
     "cash-dom": "latest",
-    "datagrok-api": "^1.5.5",
+    "datagrok-api": "^1.6.7",
     "dayjs": "^1.11.4",
     "openchemlib": "6.0.1",
     "rxjs": "^6.5.5",
@@ -48,6 +48,7 @@
     "link-api": "npm link datagrok-api",
     "link-bio": "npm link @datagrok-libraries/bio",
     "link-ml": "npm link @datagrok-libraries/ml",
+    "link-utils": "npm link @datagrok-libraries/utils",
     "link-all": "npm link datagrok-api @datagrok-libraries/utils @datagrok-libraries/bio @datagrok-libraries/ml",
     "debug-sequences1": "grok publish",
     "release-sequences1": "grok publish --release",

package/src/package-test.ts

@@ -13,6 +13,7 @@ import './tests/renderers-test';
 import './tests/convert-test';
 import './tests/fasta-handler-test';
 import './tests/WebLogo-positions-test';
+import './tests/checkInputColumn-tests'
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -15,7 +15,7 @@ import {Aminoacids} from '@datagrok-libraries/bio/src/aminoacids';
 import {getEmbeddingColsNames, sequenceSpace} from './utils/sequence-space';
 import {AvailableMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
-import {drawSequences, sequenceGetSimilarities} from './utils/sequence-activity-cliffs';
+import {createPropPanelElement, createTooltipElement, getSimilaritiesMarix} from './utils/sequence-activity-cliffs';
 import {createJsonMonomerLibFromSdf, encodeMonomers, getMolfilesFromSeq, HELM_CORE_LIB_FILENAME} from './utils/utils';
 import {getMacroMol} from './utils/atomic-works';
 import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
@@ -30,6 +30,9 @@ import {
   performanceTest
 } from './tests/test-sequnces-generators';
 
+import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
+import * as C from './utils/constants';
+
 //tags: init
 export async function initBio() {
 }
@@ -63,29 +66,50 @@ export function separatorSequenceCellRenderer(): MacromoleculeSequenceCellRender
   return new MacromoleculeSequenceCellRenderer();
 }
 
-function checkInputColumn(col: DG.Column, name: string,
-  allowedNotations: string[] = [], allowedAlphabets: string[] = []): boolean {
-  const notation: string = col.getTag(DG.TAGS.UNITS);
-  const alphabet: string = col.getTag('alphabet');
+function checkInputColumnUi(
+  col: DG.Column, name: string, allowedNotations: string[] = [], allowedAlphabets: string[] = []
+): boolean {
+  const [res, msg]: [boolean, string] = checkInputColumn(col, name, allowedNotations, allowedAlphabets);
+  if (!res)
+    grok.shell.warning(msg);
+  return res;
+}
+
+export function checkInputColumn(
+  col: DG.Column, name: string, allowedNotations: string[] = [], allowedAlphabets: string[] = []
+): [boolean, string] {
+  let res: boolean = true;
+  let msg: string = '';
+
+  const uh = new UnitsHandler(col);
   if (col.semType !== DG.SEMTYPE.MACROMOLECULE) {
     grok.shell.warning(name + ' analysis is allowed for Macromolecules semantic type');
-    return false;
-  } else if (
-    (allowedAlphabets.length > 0 &&
-      !allowedAlphabets.some((a) => alphabet.toUpperCase() == (a.toUpperCase()))) ||
-    (allowedNotations.length > 0 &&
-      !allowedNotations.some((n) => notation.toUpperCase() == (n.toUpperCase())))
-  ) {
-    const notationAdd = allowedNotations.length == 0 ? 'any notation' :
-      (`notation${allowedNotations.length > 1 ? 's' : ''} ${allowedNotations.map((n) => `"${n}"`).join(', ')} `);
-    const alphabetAdd = allowedNotations.length == 0 ? 'any alphabet' :
-      (`alphabet${allowedAlphabets.length > 1 ? 's' : ''} ${allowedAlphabets.map((a) => `"${a}"`).join(', ')}.`);
-
-    grok.shell.warning(name + ' analysis is allowed for Macromolecules with ' + notationAdd + ' and ' + alphabetAdd);
-    return false;
+    res = false;
+  } else {
+    const notation: string = uh.notation;
+    if (allowedNotations.length > 0 &&
+      !allowedNotations.some((n) => notation.toUpperCase() == (n.toUpperCase()))
+    ) {
+      const notationAdd = allowedNotations.length == 0 ? 'any notation' :
+        (`notation${allowedNotations.length > 1 ? 's' : ''} ${allowedNotations.map((n) => `"${n}"`).join(', ')} `);
+      msg = `${name} + ' analysis is allowed for Macromolecules with notation ${notationAdd}.`;
+      res = false;
+    } else if (!uh.isHelm()) {
+      // alphabet is not specified for 'helm' notation
+      const alphabet: string = uh.alphabet;
+      if (
+        allowedAlphabets.length > 0 &&
+        !allowedAlphabets.some((a) => alphabet.toUpperCase() == (a.toUpperCase()))
+      ) {
+        const alphabetAdd = allowedAlphabets.length == 0 ? 'any alphabet' :
+          (`alphabet${allowedAlphabets.length > 1 ? 's' : ''} ${allowedAlphabets.map((a) => `"${a}"`).join(', ')}.`);
+        msg = `${name} + ' analysis is allowed for Macromolecules with alphabet ${alphabetAdd}.`;
+        res = false;
+      }
+    }
   }
 
-  return true;
+  return [res, msg];
 }
 
 //name: sequenceAlignment
@@ -128,7 +152,7 @@ export function vdRegionViewer() {
 //input: string methodName { choices:["UMAP", "t-SNE", "SPE"] }
 export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column, activities: DG.Column,
   similarity: number, methodName: string): Promise<DG.Viewer | undefined> {
-  if (!checkInputColumn(macroMolecule, 'Activity Cliffs'))
+  if (!checkInputColumnUi(macroMolecule, 'Activity Cliffs'))
     return;
   const encodedCol = encodeMonomers(macroMolecule);
   if (!encodedCol)
@@ -156,8 +180,9 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
     DG.SEMTYPE.MACROMOLECULE,
     tags,
     sequenceSpace,
-    sequenceGetSimilarities,
-    drawSequences,
+    getSimilaritiesMarix,
+    createTooltipElement,
+    createPropPanelElement,
     (options as any)[methodName]);
   return sp;
 }
@@ -171,7 +196,7 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
 //input: bool plotEmbeddings = true
 export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: DG.Column, methodName: string,
   similarityMetric: string = 'Levenshtein', plotEmbeddings: boolean): Promise<DG.Viewer | undefined> {
-  if (!checkInputColumn(macroMolecule, 'Activity Cliffs'))
+  if (!checkInputColumnUi(macroMolecule, 'Activity Cliffs'))
     return;
   const encodedCol = encodeMonomers(macroMolecule);
   if (!encodedCol)
@@ -213,7 +238,7 @@ export async function toAtomicLevel(df: DG.DataFrame, macroMolecule: DG.Column):
     grok.shell.warning('Transformation to atomic level requires package "Chem" installed.');
     return;
   }
-  if (!checkInputColumn(macroMolecule, 'To Atomic Level'))
+  if (!checkInputColumnUi(macroMolecule, 'To Atomic Level'))
     return;
 
   const monomersLibFile = await _package.files.readAsText(HELM_CORE_LIB_FILENAME);
@@ -232,10 +257,12 @@ export async function toAtomicLevel(df: DG.DataFrame, macroMolecule: DG.Column):
 //top-menu: Bio | MSA...
 //name: MSA
 //input: dataframe table
-//input: column sequence { semType: Macromolecule }
+//input: column sequence { semType: Macromolecule, units: ['fasta'], alphabet: ['DNA', 'RNA', 'PT'] }
 //output: column result
 export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.Column): Promise<DG.Column | null> {
-  if (!checkInputColumn(col, 'MSA', ['fasta'], ['DNA', 'RNA', 'PT']))
+  const func: DG.Func = DG.Func.find({package: 'Bio', name: 'multipleSequenceAlignmentAny'})[0];
+
+  if (!checkInputColumnUi(col, 'MSA', ['fasta'], ['DNA', 'RNA', 'PT']))
     return null;
 
   const unUsedName = table.columns.getUnusedName(`msa(${col.name})`);
@@ -276,7 +303,7 @@ export async function compositionAnalysis(): Promise<void> {
   });
 
   const handler = async (col: DG.Column) => {
-    if (!checkInputColumn(col, 'Composition'))
+    if (!checkInputColumnUi(col, 'Composition'))
       return;
 
     const wlViewer = tv.addViewer('WebLogo', {sequenceColumnName: col.name});
@@ -391,11 +418,11 @@ export async function testDetectMacromolecule(path: string): Promise<DG.DataFram
           //console.warn(`file: ${fileInfo.path}, column: ${col.name}, ` +
           //  `semType: ${semType}, units: ${col.getTag(DG.TAGS.UNITS)}`);
           // console.warn('file: "' + fileInfo.path + '", semType: "' + semType + '", ' +
-          //   'units: "' + col.getTag('units') + '"');
+          //   'units: "' + col.getTag(DG.TAGS.UNITS) + '"');
 
           res.push({
             file: fileInfo.path, result: 'detected', column: col.name,
-            message: `units: ${col.getTag('units')}`
+            message: `units: ${col.getTag(DG.TAGS.UNITS)}`
           });
         }
       }
@@ -418,3 +445,19 @@ export async function testDetectMacromolecule(path: string): Promise<DG.DataFram
   return resDf;
 }
 
+//name: Bio | Split to monomers
+//tags: panel, bio
+//input: column col {semType: Macromolecule}
+export function splitToMonomers(col: DG.Column<string>): void {
+  if (!col.getTag(UnitsHandler.TAGS.aligned).includes(C.MSA))
+    return grok.shell.error('Splitting is applicable only for aligned sequences');
+
+  const tempDf = splitAlignedSequences(col);
+  const originalDf = col.dataFrame;
+  for (const tempCol of tempDf.columns) {
+    const newCol = originalDf.columns.add(tempCol);
+    newCol.semType = C.SEM_TYPES.MONOMER;
+    // newCol.setTag(DG.TAGS.CELL_RENDERER, C.SEM_TYPES.MONOMER);
+    newCol.setTag(C.TAGS.ALPHABET, col.getTag(C.TAGS.ALPHABET));
+  }
+}

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

@@ -5,6 +5,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {PositionInfo, PositionMonomerInfo, WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
 import {Column} from 'datagrok-api/dg';
+import {ALPHABET, NOTATION, UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 category('WebLogo-positions', () => {
   let tvList: DG.TableView[];
@@ -35,9 +36,9 @@ ATC-G-TTGC--
     const tv: DG.TableView = grok.shell.addTableView(df);
 
     const seqCol: DG.Column = df.getCol('seq');
-    seqCol.semType = 'Macromolecule';
-    seqCol.setTag('units', 'fasta');
-    seqCol.setTag('alphabet', 'DNA');
+    seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    seqCol.setTag(UnitsHandler.TAGS.alphabet, ALPHABET.DNA);
 
     const wlViewer: WebLogo = await df.plot.fromType('WebLogo') as unknown as WebLogo;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
@@ -84,9 +85,9 @@ ATC-G-TTGC--
     const tv: DG.TableView = grok.shell.addTableView(df);
 
     const seqCol: DG.Column = df.getCol('seq');
-    seqCol.semType = 'Macromolecule';
-    seqCol.setTag('units', 'fasta');
-    seqCol.setTag('alphabet', 'DNA');
+    seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    seqCol.setTag(UnitsHandler.TAGS.alphabet, ALPHABET.DNA);
 
     df.filter.init((i) => {
       return i > 2;
@@ -129,9 +130,9 @@ ATC-G-TTGC--
     const tv: DG.TableView = grok.shell.addTableView(df);
 
     const seqCol: DG.Column = df.getCol('seq');
-    seqCol.semType = 'Macromolecule';
-    seqCol.setTag('units', 'fasta');
-    seqCol.setTag('alphabet', 'DNA');
+    seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    seqCol.setTag(UnitsHandler.TAGS.alphabet, ALPHABET.DNA);
 
     const wlViewer: WebLogo = await df.plot.fromType('WebLogo', {'skipEmptyPositions': true}) as unknown as WebLogo;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);

package/src/tests/checkInputColumn-tests.ts

@@ -0,0 +1,72 @@
+import {after, before, category, test, expect, expectArray} 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 {checkInputColumn, multipleSequenceAlignmentAny} from '../package';
+import {UNITS} from 'datagrok-api/dg';
+import {ALPHABET, UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+
+
+category('checkInputColumn', () => {
+
+  const csv = `seq
+seq1,
+seq2,
+seq3,
+seq4`;
+
+  test('testMsaPos', async () => {
+    const func: DG.Func = DG.Func.find({package: 'Bio', name: 'multipleSequenceAlignmentAny'})[0];
+    const funcInputColumnProperty: DG.Property = func.inputs.find((i) => i.name == 'sequence')!;
+
+    let k = 11;
+
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+    const col: DG.Column = df.getCol('seq');
+    col.semType = DG.SEMTYPE.MACROMOLECULE;
+    col.setTag(DG.TAGS.UNITS, 'fasta');
+    col.setTag(UnitsHandler.TAGS.alphabet, ALPHABET.DNA);
+
+    const [res, msg]: [boolean, string] = checkInputColumn(
+      col, 'Test', ['fasta',], ['DNA', 'RNA', 'PT']);
+
+    expect(res, true);
+  });
+
+  test('testMsaNegHelm', async () => {
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+    const col: DG.Column = df.getCol('seq');
+    col.semType = DG.SEMTYPE.MACROMOLECULE;
+    col.setTag(DG.TAGS.UNITS, 'helm');
+    col.setTag(UnitsHandler.TAGS.alphabetSize, '11');
+    col.setTag(UnitsHandler.TAGS.alphabetIsMultichar, 'true');
+
+    const [res, msg]: [boolean, string] = checkInputColumn(
+      col, 'Test', ['fasta',], ['DNA', 'RNA', 'PT']);
+
+    expect(res, false);
+  });
+
+  test('testMsaNegUN', async () => {
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+    const col: DG.Column = df.getCol('seq');
+    col.semType = DG.SEMTYPE.MACROMOLECULE;
+    col.setTag(DG.TAGS.UNITS, 'fasta');
+    col.setTag(UnitsHandler.TAGS.alphabet, 'UN');
+    col.setTag(UnitsHandler.TAGS.alphabetSize, '11');
+    col.setTag(UnitsHandler.TAGS.alphabetIsMultichar, 'true');
+
+    const [res, msg]: [boolean, string] = checkInputColumn(
+      col, 'Test', ['fasta',], ['DNA', 'RNA', 'PT']);
+
+    expect(res, false);
+  });
+
+  test('testGetActionFunctionMeta', async () => {
+    const func: DG.Func = DG.Func.find({package: 'Bio', name: 'multipleSequenceAlignmentAny'})[0];
+    const sequenceInput: DG.Property = func.inputs.find((i) => i.name == 'sequence')!;
+    let k = 11;
+  });
+});

package/src/tests/convert-test.ts

@@ -5,7 +5,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {ConverterFunc} from './types';
 import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {NOTATION, UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 // import {mmSemType} from '../const';
 // import {importFasta} from '../package';
@@ -145,14 +145,17 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
 
   async function _testConvert(srcKey: string, converter: ConverterFunc, tgtKey: string) {
     const srcDf: DG.DataFrame = await readCsv(srcKey);
-    const srcCol: DG.Column = srcDf.col('seq')!;
+    const srcCol: DG.Column = srcDf.getCol('seq');
 
+    // conversion results
     const resCol: DG.Column = converter(srcCol);
 
+    // The correct reference data to compare conversion results with.
     const tgtDf: DG.DataFrame = await readCsv(tgtKey);
-    const tgtCol: DG.Column = tgtDf.col('seq')!;
+    const tgtCol: DG.Column = tgtDf.getCol('seq');
 
     expectArray(resCol.toList(), tgtCol.toList());
+    const uh: UnitsHandler = new UnitsHandler(resCol);
   }
 
   // FASTA tests

package/src/tests/detectors-test.ts

@@ -400,10 +400,10 @@ export async function _testPos(
 
   expect(col.semType === DG.SEMTYPE.MACROMOLECULE, true);
   expect(col.getTag(DG.TAGS.UNITS), units);
-  expect(col.getTag('aligned'), aligned);
-  expect(col.getTag('alphabet'), alphabet);
+  expect(col.getTag(UnitsHandler.TAGS.aligned), aligned);
+  expect(col.getTag(UnitsHandler.TAGS.alphabet), alphabet);
   if (separator)
-    expect(col.getTag('separator'), separator);
+    expect(col.getTag(UnitsHandler.TAGS.separator), separator);
 
   const uh = new UnitsHandler(col);
   expect(uh.getAlphabetSize(), alphabetSize);

package/src/tests/renderers-test.ts

@@ -3,9 +3,9 @@ import {after, before, category, delay, expect, test} from '@datagrok-libraries/
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import {importFasta, multipleSequenceAlignmentAny} from '../package';
-import {readDataframe} from './utils';
 import {convertDo} from '../utils/convert';
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {ALPHABET, NOTATION, UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SEM_TYPES, TAGS} from '../utils/constants';
 
 category('renderers', () => {
   let tvList: DG.TableView[];
@@ -30,33 +30,45 @@ category('renderers', () => {
     await _testAfterConvert();
   });
 
+  test('setRenderer', async () => {
+    await _setRendererManually();
+  });
+
   async function _testAfterMsa() {
     const fastaTxt: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.fasta');
     const df: DG.DataFrame = importFasta(fastaTxt)[0];
+
+    const srcSeqCol: DG.Column = df.getCol('sequence');
+    const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: srcSeqCol});
+    if (semType)
+      srcSeqCol.semType = semType;
+
     const tv: DG.TableView = grok.shell.addTableView(df);
+    // call to calculate 'cell.renderer' tag
     await grok.data.detectSemanticTypes(df);
-    console.log('Bio: tests/renderers/afterMsa, table view');
 
-    const srcSeqCol: DG.Column | null = df.col('sequence');
-    expect(srcSeqCol !== null, true);
+    console.log('Bio: tests/renderers/afterMsa, table view');
 
     console.log('Bio: tests/renderers/afterMsa, src before test ' +
       `semType="${srcSeqCol!.semType}", units="${srcSeqCol!.getTag(DG.TAGS.UNITS)}", ` +
-      `cell.renderer="${srcSeqCol!.getTag('cell.renderer')}"`);
-    expect(srcSeqCol!.semType, DG.SEMTYPE.MACROMOLECULE);
-    expect(srcSeqCol!.getTag(DG.TAGS.UNITS), 'fasta');
-    expect(srcSeqCol!.getTag('aligned'), 'SEQ');
-    expect(srcSeqCol!.getTag('alphabet'), 'PT');
-    expect(srcSeqCol!.getTag('cell.renderer'), 'sequence');
-
-    const msaSeqCol: DG.Column | null = await multipleSequenceAlignmentAny(df, srcSeqCol!);
+      `cell.renderer="${srcSeqCol!.getTag(DG.TAGS.CELL_RENDERER)}"`);
+    expect(srcSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
+    expect(srcSeqCol.getTag(DG.TAGS.UNITS), NOTATION.FASTA);
+    expect(srcSeqCol.getTag(UnitsHandler.TAGS.aligned), 'SEQ');
+    expect(srcSeqCol.getTag(UnitsHandler.TAGS.alphabet), ALPHABET.PT);
+    expect(srcSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
+
+    const msaSeqCol: DG.Column = (await multipleSequenceAlignmentAny(df, srcSeqCol!))!;
     tv.grid.invalidate();
-    
-    expect(msaSeqCol!.semType, DG.SEMTYPE.MACROMOLECULE);
-    expect(msaSeqCol!.getTag(DG.TAGS.UNITS), 'fasta');
-    expect(msaSeqCol!.getTag('aligned'), 'SEQ.MSA');
-    expect(msaSeqCol!.getTag('alphabet'), 'PT');
-    expect(msaSeqCol!.getTag('cell.renderer'), 'sequence');
+
+    expect(msaSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
+    expect(msaSeqCol.getTag(DG.TAGS.UNITS), NOTATION.FASTA);
+    expect(msaSeqCol.getTag(UnitsHandler.TAGS.aligned), 'SEQ.MSA');
+    expect(msaSeqCol.getTag(UnitsHandler.TAGS.alphabet), ALPHABET.PT);
+    expect(msaSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
+
+    // check newColumn with UnitsHandler constructor
+    const uh: UnitsHandler = new UnitsHandler(msaSeqCol);
 
     dfList.push(df);
     tvList.push(tv);
@@ -66,13 +78,35 @@ category('renderers', () => {
     const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA_PT.csv');
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
     const tv: DG.TableView = grok.shell.addTableView(df);
-    await grok.data.detectSemanticTypes(df);
 
     const srcCol: DG.Column = df.col('sequence')!;
+    // await grok.data.detectSemanticTypes(df);
+    const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: srcCol});
+    if (semType)
+      srcCol.semType = semType;
+    await grok.data.detectSemanticTypes(df);
+
     const tgtCol: DG.Column = await convertDo(srcCol, NOTATION.SEPARATOR, '/');
-    expect(tgtCol.getTag('cell.renderer'), 'sequence');
+    expect(tgtCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
+
+    // check tgtCol with UnitsHandler constructor
+    const uh: UnitsHandler = new UnitsHandler(tgtCol);
 
     tvList.push(tv);
     dfList.push(df);
-  };
+  }
+
+  async function _setRendererManually() {
+    const df = DG.DataFrame.fromColumns([DG.Column.fromStrings(
+      'SequencesDiff', ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV'])]);
+    df.col('SequencesDiff')!.tags[DG.TAGS.UNITS] = 'separator';
+    df.col('SequencesDiff')!.tags[TAGS.SEPARATOR] = '/';
+    df.col('SequencesDiff')!.semType = SEM_TYPES.MACROMOLECULE_DIFFERENCE;
+    const tw = grok.shell.addTableView(df);
+    await delay(100);
+    const renderer = tw.dataFrame.col('SequencesDiff')?.getTag(DG.TAGS.CELL_RENDERER);
+    if (renderer !== 'MacromoleculeDifferenceCR')
+      throw new Error(`Units 'separator', separator '/' and semType 'MacromoleculeDifference' have been ` +
+        `manually set on column but after df aws added as table view renderer has been reset to '${renderer}'`);
+  }
 });

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

@@ -1,10 +1,15 @@
 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 {expect} from '@datagrok-libraries/utils/src/test';
+import {sequenceSpaceTopMenu} from '../package';
 
 export async function _testSequenceSpaceReturnsResult(df: DG.DataFrame, algorithm: string, colName: string) {
-  await grok.data.detectSemanticTypes(df);
+  // await grok.data.detectSemanticTypes(df);
+  const col: DG.Column = df.getCol(colName);
+  const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: col});
+  if (semType)
+    col.semType = semType;
+
   const sp = await sequenceSpaceTopMenu(df, df.col(colName)!, algorithm, 'Levenshtein', true);
   expect(sp != null, true);
 }

package/src/tests/splitters-test.ts

@@ -4,6 +4,8 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {WebLogo, SplitterFunc} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {splitToMonomers, _package} from '../package';
+import * as C from '../utils/constants';
 
 category('splitters', () => {
   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}$$$';
@@ -51,6 +53,19 @@ category('splitters', () => {
   test('testHelm1', async () => { await _testHelmSplitter(data.testHelm1[0], data.testHelm1[1]); });
   test('testHelm2', async () => { await _testHelmSplitter(data.testHelm2[0], data.testHelm2[1]); });
   test('testHelm3', async () => { await _testHelmSplitter(data.testHelm3[0], data.testHelm3[1]); });
+
+  test('splitToMonomers', async () => {
+    const df: DG.DataFrame = await grok.dapi.files.readCsv('System:AppData/Bio/samples/sample_MSA.csv');
+
+    const seqCol = df.getCol('MSA');
+    const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+    if (semType)
+      seqCol.semType = semType;
+    seqCol.setTag(C.TAGS.ALIGNED, C.MSA);
+
+    splitToMonomers(seqCol);
+    expect(df.columns.names().includes('17'), true);
+  });
 });
 
 export async function _testHelmSplitter(src: string, tgt: string[]) {

package/src/tests/test-sequnces-generators.ts

@@ -1,27 +1,22 @@
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+import {DataFrame} from 'datagrok-api/dg';
 
-export function generateManySequences(): string {
-  let csvData = `MSA,Activity
-meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me,5.30751`;
-  for (let i = 0; i < 10 ** 6; i++) {
-    csvData += `\n meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me,5.30751`;
-  }
-  return csvData;
+export function generateManySequences(): DG.Column[] {
+  let 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(): string {
-  let longSequence = `meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr`;
-  for (let i = 0; i < 10 ** 5; i++) {
-    longSequence += `/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/dv`;
-  }
-  longSequence += `//Phe_4Me,5.30751`;
-  let csvData = `MSA,Activity `;
-  for (let i = 0; i <= 10 ** 1 * 4; i++) {
-    csvData += `\n ${longSequence}`;
-  }
-  return csvData;
+export function generateLongSequence(): DG.Column[] {
+  let 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')));
+  return columns;
 }
+
 export function setTagsMacromolecule(col: DG.Column) {
   col.semType = DG.SEMTYPE.MACROMOLECULE;
   col.setTag('units', 'separator');
@@ -31,10 +26,10 @@ export function setTagsMacromolecule(col: DG.Column) {
   return col;
 }
 
-export function performanceTest(generateFunc: () => string,testName: string) {
+export function performanceTest(generateFunc: () => DG.Column[], testName: string) {
+  const columns = generateFunc();
+  const df: DG.DataFrame = DG.DataFrame.fromColumns(columns);
   const startTime: number = Date.now();
-  const csv = generateFunc();
-  const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
   const col: DG.Column = df.columns.byName('MSA');
   setTagsMacromolecule(col);
   grok.shell.addTableView(df);