@datagrok/bio 1.9.0 → 1.11.0

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -14,16 +14,17 @@
   },
   "dependencies": {
     "@biowasm/aioli": ">=2.4.0",
-    "@datagrok-libraries/bio": "^3.1.1",
+    "@datagrok-libraries/bio": "^4.2.0",
+    "@datagrok-libraries/chem-meta": "1.0.0",
     "@datagrok-libraries/ml": "^4.0.0",
     "@datagrok-libraries/utils": "^1.6.2",
     "cash-dom": "latest",
-    "datagrok-api": "^1.5.5",
+    "datagrok-api": "^1.6.6",
     "dayjs": "^1.11.4",
     "openchemlib": "6.0.1",
     "rxjs": "^6.5.5",
-    "ts-loader": "^9.2.5",
-    "typescript": "^4.4.2"
+    "typescript": "^4.4.2",
+    "wu": "latest"
   },
   "devDependencies": {
     "@types/jest": "^27.0.0",
@@ -35,6 +36,7 @@
     "jest-html-reporter": "^3.6.0",
     "puppeteer": "^13.7.0",
     "ts-jest": "^27.0.0",
+    "ts-loader": "^9.2.5",
     "webpack": "latest",
     "webpack-cli": "^4.10.0",
     "@types/js-yaml": "^4.0.5",
@@ -67,11 +69,7 @@
     "Developers"
   ],
   "sources": [
-    "css/helm.css",
-    "https://ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/dojo.js",
-    "helm/JSDraw/Scilligence.JSDraw2.Lite.js",
-    "helm/JSDraw/Scilligence.JSDraw2.Resources.js",
-    "helm/JSDraw/Pistoia.HELM-uncompressed.js"
+    "css/helm.css"
   ],
   "category": "Bioinformatics"
 }

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

@@ -23,13 +23,31 @@ import {convert} from './utils/convert';
 import {representationsWidget} from './widgets/representations';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
-import {removeEmptyStringRows} from '@datagrok-libraries/utils/src/dataframe-utils'
+import {removeEmptyStringRows} from '@datagrok-libraries/utils/src/dataframe-utils';
+import {
+  generateManySequences,
+  generateLongSequence,
+  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() {
 }
 
+//name: testManySequencesPerformance
+export function testManySequencesPerformance(): void {
+  performanceTest(generateManySequences, 'Many sequences');
+}
+
+//name: testLongSequencesPerformance
+export function testLongSequencesPerformance(): void {
+  performanceTest(generateLongSequence, 'Long sequences');
+}
+
+
 //name: fastaSequenceCellRenderer
 //tags: cellRenderer
 //meta.cellType: Sequence
@@ -48,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
@@ -113,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)
@@ -127,7 +166,7 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
     'aligned': macroMolecule.tags['aligned'],
     'separator': macroMolecule.tags['separator'],
     'alphabet': macroMolecule.tags['alphabet'],
-  }
+  };
   const sp = await getActivityCliffs(
     df,
     macroMolecule,
@@ -144,7 +183,7 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
     sequenceGetSimilarities,
     drawSequences,
     (options as any)[methodName]);
-    return sp;
+  return sp;
 }
 
 //top-menu: Bio | Sequence Space...
@@ -155,18 +194,18 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
 //input: string similarityMetric { choices:["Levenshtein", "Tanimoto"] }
 //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'))
+  similarityMetric: string = 'Levenshtein', plotEmbeddings: boolean): Promise<DG.Viewer | undefined> {
+  if (!checkInputColumnUi(macroMolecule, 'Activity Cliffs'))
     return;
   const encodedCol = encodeMonomers(macroMolecule);
   if (!encodedCol)
     return;
   const embedColsNames = getEmbeddingColsNames(table);
-  const withoutEmptyValues = DG.DataFrame.fromColumns([macroMolecule]).clone();
+  const withoutEmptyValues = DG.DataFrame.fromColumns([encodedCol]).clone();
   const emptyValsIdxs = removeEmptyStringRows(withoutEmptyValues, encodedCol);
 
   const chemSpaceParams = {
-    seqCol: withoutEmptyValues.col(macroMolecule.name)!,
+    seqCol: withoutEmptyValues.col(encodedCol.name)!,
     methodName: methodName,
     similarityMetric: similarityMetric,
     embedAxesNames: embedColsNames
@@ -174,11 +213,11 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
   const sequenceSpaceRes = await sequenceSpace(chemSpaceParams);
   const embeddings = sequenceSpaceRes.coordinates;
   for (const col of embeddings) {
-      const listValues = col.toList();
-      emptyValsIdxs.forEach((ind: number) => listValues.splice(ind, 0, null));
-      table.columns.add(DG.Column.fromList('double', col.name, listValues));
+    const listValues = col.toList();
+    emptyValsIdxs.forEach((ind: number) => listValues.splice(ind, 0, null));
+    table.columns.add(DG.Column.fromList('double', col.name, listValues));
   }
-  let sp;   
+  let sp;
   if (plotEmbeddings) {
     for (const v of grok.shell.views) {
       if (v.name === table.name)
@@ -198,7 +237,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);
@@ -217,10 +256,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})`);
@@ -261,7 +302,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});
@@ -376,11 +417,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)}`
           });
         }
       }
@@ -403,3 +444,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[];
@@ -12,11 +13,11 @@ category('WebLogo-positions', () => {
   let currentView: DG.View;
 
   const csvDf1 = `seq
-    ATC-G-TTGC--
-    ATC-G-TTGC--
-    -TC-G-TTGC--
-    -TC-GCTTGC--
-    -TC-GCTTGC--`;
+ATC-G-TTGC--
+ATC-G-TTGC--
+-TC-G-TTGC--
+-TC-GCTTGC--
+-TC-GCTTGC--`;
 
 
   before(async () => {
@@ -34,8 +35,10 @@ category('WebLogo-positions', () => {
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf1);
     const tv: DG.TableView = grok.shell.addTableView(df);
 
-    df.getCol('seq').semType = 'Macromolecule';
-    df.getCol('seq').setTag('units', 'fasta:SEQ.MSA:DNA');
+    const seqCol: DG.Column = df.getCol('seq');
+    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);
@@ -81,10 +84,11 @@ category('WebLogo-positions', () => {
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf2);
     const tv: DG.TableView = grok.shell.addTableView(df);
 
-    df.getCol('seq').semType = 'Macromolecule';
-    df.getCol('seq').setTag('units', 'fasta:SEQ.MSA:DNA');
+    const seqCol: DG.Column = df.getCol('seq');
+    seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    seqCol.setTag(UnitsHandler.TAGS.alphabet, ALPHABET.DNA);
 
-    let seq: Column = df.getCol('seq');
     df.filter.init((i) => {
       return i > 2;
     });
@@ -125,8 +129,10 @@ category('WebLogo-positions', () => {
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf1);
     const tv: DG.TableView = grok.shell.addTableView(df);
 
-    df.getCol('seq').semType = 'Macromolecule';
-    df.getCol('seq').setTag('units', 'fasta:SEQ.MSA:DNA');
+    const seqCol: DG.Column = df.getCol('seq');
+    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);
@@ -156,7 +162,6 @@ category('WebLogo-positions', () => {
         expect(positions[i].freq[key].count, resAllDf1[i].freq[key].count);
       }
     }
-
   });
 
 });

package/src/tests/checkInputColumn-tests.ts

@@ -0,0 +1,69 @@
+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} 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`;
+
+  category('MSA', () => {
+
+    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);
+    });
+  });
+});

package/src/tests/detectors-test.ts

@@ -5,6 +5,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {importFasta} from '../package';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 type DfReaderFunc = () => Promise<DG.DataFrame>;
 
@@ -198,44 +199,44 @@ MWRSWY-CKHP
   test('NegativeSmiles', async () => { await _testNeg(readCsv('csvDfSmiles', csvDfSmiles), 'col1'); });
 
   test('Dna1', async () => {
-    await _testPos(readCsv('csvDfDna1', csvDfDna1), 'seq', 'fasta', 'SEQ', 'DNA');
+    await _testPos(readCsv('csvDfDna1', csvDfDna1), 'seq', 'fasta', 'SEQ', 'DNA', 4, false);
   });
   test('Rna1', async () => {
-    await _testPos(readCsv('csvDfRna1', csvDfRna1), 'seq', 'fasta', 'SEQ', 'RNA');
+    await _testPos(readCsv('csvDfRna1', csvDfRna1), 'seq', 'fasta', 'SEQ', 'RNA', 4, false);
   });
   test('AA1', async () => {
-    await _testPos(readCsv('csvDfPt1', csvDfPt1), 'seq', 'fasta', 'SEQ', 'PT');
+    await _testPos(readCsv('csvDfPt1', csvDfPt1), 'seq', 'fasta', 'SEQ', 'PT', 20, false);
   });
   test('MsaDna1', async () => {
-    await _testPos(readCsv('csvDfMsaDna1', csvDfMsaDna1), 'seq', 'fasta', 'SEQ.MSA', 'DNA');
+    await _testPos(readCsv('csvDfMsaDna1', csvDfMsaDna1), 'seq', 'fasta', 'SEQ.MSA', 'DNA', 4, false);
   });
 
   test('MsaAA1', async () => {
-    await _testPos(readCsv('csvDfMsaPt1', csvDfMsaPt1), 'seq', 'fasta', 'SEQ.MSA', 'PT');
+    await _testPos(readCsv('csvDfMsaPt1', csvDfMsaPt1), 'seq', 'fasta', 'SEQ.MSA', 'PT', 20, false);
   });
 
   test('SepDna', async () => {
-    await _testPos(readCsv('csvDfSepDna', csvDfSepDna), 'seq', 'separator', 'SEQ', 'DNA', '*');
+    await _testPos(readCsv('csvDfSepDna', csvDfSepDna), 'seq', 'separator', 'SEQ', 'DNA', 4, false, '*');
   });
   test('SepRna', async () => {
-    await _testPos(readCsv('csvDfSepRna', csvDfSepRna), 'seq', 'separator', 'SEQ', 'RNA', '*');
+    await _testPos(readCsv('csvDfSepRna', csvDfSepRna), 'seq', 'separator', 'SEQ', 'RNA', 4, false, '*');
   });
   test('SepPt', async () => {
-    await _testPos(readCsv('csvDfSepPt', csvDfSepPt), 'seq', 'separator', 'SEQ', 'PT', '-');
+    await _testPos(readCsv('csvDfSepPt', csvDfSepPt), 'seq', 'separator', 'SEQ', 'PT', 20, false, '-');
   });
   test('SepUn1', async () => {
-    await _testPos(readCsv('csvDfSepUn1', csvDfSepUn1), 'seq', 'separator', 'SEQ', 'UN', '-');
+    await _testPos(readCsv('csvDfSepUn1', csvDfSepUn1), 'seq', 'separator', 'SEQ', 'UN', 8, true, '-');
   });
   test('SepUn2', async () => {
-    await _testPos(readCsv('csvDfSepUn2', csvDfSepUn2), 'seq', 'separator', 'SEQ', 'UN', '/');
+    await _testPos(readCsv('csvDfSepUn2', csvDfSepUn2), 'seq', 'separator', 'SEQ', 'UN', 9, true, '/');
   });
 
   test('SepMsaN1', async () => {
-    await _testPos(readCsv('csvDfSepMsaDna1', csvDfSepMsaDna1), 'seq', 'separator', 'SEQ.MSA', 'DNA', '-');
+    await _testPos(readCsv('csvDfSepMsaDna1', csvDfSepMsaDna1), 'seq', 'separator', 'SEQ.MSA', 'DNA', 4, false, '-');
   });
 
   test('SamplesFastaCsvPt', async () => {
-    await _testPos(readSamples(Samples.fastaCsv), 'sequence', 'fasta', 'SEQ', 'PT');
+    await _testPos(readSamples(Samples.fastaCsv), 'sequence', 'fasta', 'SEQ', 'PT', 20, false);
   });
   test('SamplesFastaCsvNegativeEntry', async () => {
     await _testNeg(readSamples(Samples.fastaCsv), 'Entry');
@@ -248,7 +249,7 @@ MWRSWY-CKHP
   });
 
   test('SamplesFastaFastaPt', async () => {
-    await _testPos(readSamples(Samples.fastaFasta, readFileFasta), 'sequence', 'fasta', 'SEQ', 'PT');
+    await _testPos(readSamples(Samples.fastaFasta, readFileFasta), 'sequence', 'fasta', 'SEQ', 'PT', 20, false);
   });
 
   // peptidesComplex contains monomers with spaces in AlignedSequence columns, which are forbidden
@@ -266,7 +267,7 @@ MWRSWY-CKHP
   });
 
   test('samplesMsaComplexUn', async () => {
-    await _testPos(readSamples(Samples.msaComplex), 'MSA', 'separator', 'SEQ.MSA', 'UN', '/');
+    await _testPos(readSamples(Samples.msaComplex), 'MSA', 'separator', 'SEQ.MSA', 'UN', 161, true, '/');
   });
   test('samplesMsaComplexNegativeActivity', async () => {
     await _testNeg(readSamples(Samples.msaComplex), 'Activity');
@@ -281,7 +282,7 @@ MWRSWY-CKHP
   });
 
   test('samplesHelmCsvHELM', async () => {
-    await _testPos(readSamples(Samples.helmCsv), 'HELM', 'helm', null, null, null);
+    await _testPos(readSamples(Samples.helmCsv), 'HELM', 'helm', null, null, 160, true, null);
   });
 
   test('samplesHelmCsvNegativeActivity', async () => {
@@ -297,7 +298,7 @@ MWRSWY-CKHP
     await _testNeg(readSamples(Samples.testHelmCsv), 'Test type');
   });
   test('samplesTestHelmPositiveHelmString', async () => {
-    await _testPos(readSamples(Samples.testHelmCsv), 'HELM string', 'helm', null, null, null);
+    await _testPos(readSamples(Samples.testHelmCsv), 'HELM string', 'helm', null, null, 9, true, null);
   });
   test('samplesTestHelmNegativeValid', async () => {
     await _testNeg(readSamples(Samples.testHelmCsv), 'Valid?');
@@ -329,7 +330,7 @@ MWRSWY-CKHP
   });
 
   test('samplesFastaPtPosSequence', async () => {
-    await _testPos(readSamples(Samples.fastaPtCsv), 'sequence', 'fasta', 'SEQ', 'PT');
+    await _testPos(readSamples(Samples.fastaPtCsv), 'sequence', 'fasta', 'SEQ', 'PT', 20, false);
   });
 
   test('samplesTestCerealNegativeCerealName', async () => {
@@ -371,7 +372,8 @@ MWRSWY-CKHP
 export async function _testNeg(readDf: DfReaderFunc, colName: string) {
   const df: DG.DataFrame = await readDf();
   const col: DG.Column = df.col(colName)!;
-  const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: col});
+  const semType: string = await grok.functions
+    .call('Bio:detectMacromolecule', {col: col}) as unknown as string;
   if (semType)
     col.semType = semType;
 
@@ -384,18 +386,31 @@ export async function _testNeg(readDf: DfReaderFunc, colName: string) {
   }
 }
 
-export async function _testPos(readDf: DfReaderFunc, colName: string, units: string, aligned: string | null, alphabet: string | null, separator: string | null = null) {
+export async function _testPos(
+  readDf: DfReaderFunc, colName: string, units: string,
+  aligned: string | null, alphabet: string | null, alphabetSize: number, alphabetIsMultichar: boolean,
+  separator: string | null = null
+) {
   const df: DG.DataFrame = await readDf();
   const col: DG.Column = df.col(colName)!;
-  const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: col});
+  const semType: string = await grok.functions
+    .call('Bio:detectMacromolecule', {col: col}) as unknown as string;
   if (semType)
     col.semType = semType;
 
   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);
+  expect(uh.getAlphabetIsMultichar(), alphabetIsMultichar);
+  if (!uh.isHelm()) {
+    expect(uh.aligned, aligned);
+    expect(uh.alphabet, alphabet);
+  }
 }
 

package/src/tests/msa-tests.ts

@@ -49,7 +49,8 @@ async function _testMsaIsCorrect(srcCsv: string, tgtCsv: string): Promise<void>
   const tgtDf: DG.DataFrame = DG.DataFrame.fromCsv(tgtCsv);
 
   const srcCol: DG.Column = srcDf.getCol('seq')!;
-  const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: srcCol});
+  const semType: string = await grok.functions
+    .call('Bio:detectMacromolecule', {col: srcCol}) as unknown as string;
   if (semType)
     srcCol.semType = semType;
 

package/src/tests/renderers-test.ts

@@ -5,7 +5,7 @@ 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';
 
 category('renderers', () => {
   let tvList: DG.TableView[];
@@ -42,21 +42,21 @@ category('renderers', () => {
 
     console.log('Bio: tests/renderers/afterMsa, src before test ' +
       `semType="${srcSeqCol!.semType}", units="${srcSeqCol!.getTag(DG.TAGS.UNITS)}", ` +
-      `cell.renderer="${srcSeqCol!.getTag('cell.renderer')}"`);
+      `cell.renderer="${srcSeqCol!.getTag(DG.TAGS.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');
+    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 | null = 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!.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');
 
     dfList.push(df);
     tvList.push(tv);
@@ -70,7 +70,7 @@ category('renderers', () => {
 
     const srcCol: DG.Column = df.col('sequence')!;
     const tgtCol: DG.Column = await convertDo(srcCol, NOTATION.SEPARATOR, '/');
-    expect(tgtCol.getTag('cell.renderer'), 'sequence');
+    expect(tgtCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
     tvList.push(tv);
     dfList.push(df);