@datagrok/bio 2.0.18 → 2.0.20

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.0.18",
+  "version": "2.0.20",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.0.0",
+    "@datagrok-libraries/bio": "^5.1.0",
     "@datagrok-libraries/chem-meta": "1.0.1",
     "@datagrok-libraries/ml": "^6.2.0",
     "@datagrok-libraries/utils": "^1.10.1",

package/src/package.ts

@@ -31,6 +31,7 @@ import {SequenceSimilarityViewer} from './analysis/sequence-similarity-viewer';
 import {SequenceDiversityViewer} from './analysis/sequence-diversity-viewer';
 import {substructureSearchDialog} from './substructure-search/substructure-search';
 import {saveAsFastaUI} from './utils/save-as-fasta';
+import {BioSubstructureFilter} from './widgets/bio-substructure-filter';
 
 //tags: init
 export async function initBio() {
@@ -449,7 +450,7 @@ export async function testDetectMacromolecule(path: string): Promise<DG.DataFram
 //tags: panel, bio
 //input: column col {semType: Macromolecule}
 export function splitToMonomers(col: DG.Column<string>): void {
-  if (!col.getTag(bio.UnitsHandler.TAGS.aligned).includes(C.MSA))
+  if (!col.getTag(bio.TAGS.aligned).includes(C.MSA))
     return grok.shell.error('Splitting is applicable only for aligned sequences');
 
   const tempDf = splitAlignedSequences(col);
@@ -517,4 +518,15 @@ export function bioSubstructureSearch(col: DG.Column): void {
 //tags: fileExporter
 export function saveAsFasta() {
   saveAsFastaUI();
-}
+}
+
+//name: BioSubstructureFilter
+//description: Substructure filter for linear macromolecules
+//tags: filter
+//output: filter result
+//meta.semType: Macromolecule
+export function bioSubstructureFilter(): BioSubstructureFilter {
+  return new BioSubstructureFilter();
+}
+
+

package/src/substructure-search/substructure-search.ts

@@ -1,8 +1,12 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/units-handler';
+import * as bio from '@datagrok-libraries/bio';
+
 import * as C from '../utils/constants';
+import {getMonomericMols} from '../calculations/monomerLevelMols';
+import {BitSet} from 'datagrok-api/dg';
+import {updateDivInnerHTML} from '../utils/ui-utils';
 
 /**
  * Searches substructure in each row of Macromolecule column
@@ -12,48 +16,58 @@ import * as C from '../utils/constants';
 export function substructureSearchDialog(col: DG.Column): void {
   const units = col.getTag(DG.TAGS.UNITS);
   const separator = col.getTag(C.TAGS.SEPARATOR);
-  const notations = [NOTATION.FASTA, NOTATION.SEPARATOR];
+  // const notations = [NOTATION.FASTA, NOTATION.SEPARATOR, NOTATION.HELM];
 
   const substructureInput = ui.textInput('Substructure', '');
-  const notationInput = ui.choiceInput('Notation', units, notations);
+
+  const editHelmLink = ui.link('Edit helm', async () => {
+    updateDivInnerHTML(inputsDiv, grid.root);
+    await ui.tools.waitForElementInDom(grid.root);
+    setTimeout(() => {
+      grid.cell('substr_helm', 0).element.children[0].dispatchEvent(new KeyboardEvent('keydown', {key: 'Enter'}));
+    }, 100);
+  });
+
+  const df = DG.DataFrame.create(1);
+  df.columns.addNewString('substr_helm').init((i) => '');
+  df.col('substr_helm')!.semType = col.semType;
+  df.col('substr_helm')!.setTag(DG.TAGS.UNITS, bio.NOTATION.HELM);
+  const grid = df.plot.grid();
   const separatorInput = ui.textInput('Separator', separator);
 
-  // hide the separator input for non-SEPARATOR target notations
-  const toggleSeparator = () => {
-    if (notationInput.value !== NOTATION.SEPARATOR)
-      separatorInput.root.hidden = true;
-    else
-      separatorInput.root.hidden = false;
-  };
+  const inputsDiv = ui.div();
 
-  toggleSeparator();
+  const inputs = units === bio.NOTATION.HELM ? ui.divV([editHelmLink]) :
+    units === bio.NOTATION.SEPARATOR ? ui.inputs([substructureInput, separatorInput]) :
+      ui.inputs([substructureInput]);
 
-  notationInput.onChanged(() => {
-    toggleSeparator();
-  });
+  updateDivInnerHTML(inputsDiv, inputs);
 
   ui.dialog('Substructure search')
-    .add(ui.inputs([
-      substructureInput,
-      notationInput,
-      separatorInput
+    .add(ui.divV([
+      ui.divText(`Notation: ${units}`),
+      inputsDiv
     ]))
-    .onOK(() => {
-      let substructure = substructureInput.value;
-      if (notationInput.value !== NOTATION.FASTA && separatorInput.value !== separator)
+    .onOK(async () => {
+      let substructure = units === bio.NOTATION.HELM ? df.get('substr_helm', 0) : substructureInput.value;
+      if (units === bio.NOTATION.SEPARATOR && separatorInput.value !== separator && separatorInput.value !== '')
         substructure = substructure.replaceAll(separatorInput.value, separator);
       const matchesColName = `Matches: ${substructure}`;
       const colExists = col.dataFrame.columns.names()
         .filter((it) => it.toLocaleLowerCase() === matchesColName.toLocaleLowerCase()).length > 0;
       if (!colExists) {
-        const matches = substructureSearch(substructure, col);
+        let matches: BitSet;
+        if (units === bio.NOTATION.HELM)
+          matches = await helmSubstructureSearch(substructure, col);
+        else
+          matches = linearSubstructureSearch(substructure, col);
         col.dataFrame.columns.add(DG.Column.fromBitSet(matchesColName, matches));
       } else { grok.shell.warning(`Search ${substructure} is already performed`); }
     })
     .show();
 }
 
-export function substructureSearch(substructure: string, col: DG.Column): DG.BitSet {
+export function linearSubstructureSearch(substructure: string, col: DG.Column): DG.BitSet {
   const lowerCaseSubstr = substructure.toLowerCase();
   const resultArray = DG.BitSet.create(col.length);
   for (let i = 0; i < col.length; i++) {
@@ -63,3 +77,19 @@ export function substructureSearch(substructure: string, col: DG.Column): DG.Bit
   }
   return resultArray;
 }
+
+async function helmSubstructureSearch(substructure: string, col: DG.Column): Promise<BitSet> {
+  const helmColWithSubstructure = DG.Column.string('helm', col.length + 1)
+    .init((i) => i === col.length ? substructure : col.get(i));
+  helmColWithSubstructure.setTag(DG.TAGS.UNITS, bio.NOTATION.HELM);
+  const monomericMolsCol = await getMonomericMols(helmColWithSubstructure, true);
+  const molSubstructure = monomericMolsCol.get(col.length);
+  const monomericMolsDf = DG.DataFrame.fromColumns([monomericMolsCol]);
+  monomericMolsDf.rows.removeAt(col.length);
+  const matchesCol = await grok.functions.call('Chem:searchSubstructure', {
+    molStringsColumn: monomericMolsDf.columns.byIndex(0),
+    molString: molSubstructure,
+    molBlockFailover: '',
+  });
+  return matchesCol.get(0);
+}

package/src/tests/Palettes-test.ts

@@ -1,27 +1,26 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+import * as bio from '@datagrok-libraries/bio';
 
 import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
 
 import {_testPaletteN, _testPaletteAA} from '@datagrok-libraries/bio/src/tests/palettes-tests';
-import {ALPHABET, UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
-import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
 
 category('Palettes', () => {
   test('testPaletteN', async () => { await _testPaletteN(); });
   test('testPaletteAA', async () => { await _testPaletteAA(); });
 
   test('testPalettePtMe', async () => {
-    const colorMeNle = AminoacidsPalettes.GrokGroups.get('MeNle');
-    const colorMeA = AminoacidsPalettes.GrokGroups.get('MeA');
-    const colorMeG = AminoacidsPalettes.GrokGroups.get('MeG');
-    const colorMeF = AminoacidsPalettes.GrokGroups.get('MeF');
+    const colorMeNle = bio.AminoacidsPalettes.GrokGroups.get('MeNle');
+    const colorMeA = bio.AminoacidsPalettes.GrokGroups.get('MeA');
+    const colorMeG = bio.AminoacidsPalettes.GrokGroups.get('MeG');
+    const colorMeF = bio.AminoacidsPalettes.GrokGroups.get('MeF');
 
-    const colorL = AminoacidsPalettes.GrokGroups.get('L');
-    const colorA = AminoacidsPalettes.GrokGroups.get('A');
-    const colorG = AminoacidsPalettes.GrokGroups.get('G');
-    const colorF = AminoacidsPalettes.GrokGroups.get('F');
+    const colorL = bio.AminoacidsPalettes.GrokGroups.get('L');
+    const colorA = bio.AminoacidsPalettes.GrokGroups.get('A');
+    const colorG = bio.AminoacidsPalettes.GrokGroups.get('G');
+    const colorF = bio.AminoacidsPalettes.GrokGroups.get('F');
 
     expect(colorMeNle, colorL);
     expect(colorMeA, colorA);

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

@@ -4,8 +4,6 @@ import * as DG from 'datagrok-api/dg';
 import * as bio from '@datagrok-libraries/bio';
 
 import {after, before, category, test, expect, expectObject, delay} from '@datagrok-libraries/utils/src/test';
-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[];
@@ -38,8 +36,8 @@ ATC-G-TTGC--
 
     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);
+    seqCol.setTag(DG.TAGS.UNITS, bio.NOTATION.FASTA);
+    seqCol.setTag(bio.TAGS.alphabet, bio.ALPHABET.DNA);
 
     const wlViewer: bio.WebLogo = (await df.plot.fromType('WebLogo')) as bio.WebLogo;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
@@ -87,8 +85,8 @@ ATC-G-TTGC--
 
     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);
+    seqCol.setTag(DG.TAGS.UNITS, bio.NOTATION.FASTA);
+    seqCol.setTag(bio.TAGS.alphabet, bio.ALPHABET.DNA);
 
     df.filter.init((i) => {
       return i > 2;
@@ -131,8 +129,8 @@ ATC-G-TTGC--
 
     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);
+    seqCol.setTag(DG.TAGS.UNITS, bio.NOTATION.FASTA);
+    seqCol.setTag(bio.TAGS.alphabet, bio.ALPHABET.DNA);
 
     const wlViewer: bio.WebLogo = (await df.plot.fromType('WebLogo',
       {'skipEmptyPositions': true})) as bio.WebLogo;

package/src/tests/checkInputColumn-tests.ts

@@ -1,12 +1,13 @@
-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 * as bio from '@datagrok-libraries/bio';
+
+
+import {after, before, category, test, expect, expectArray} from '@datagrok-libraries/utils/src/test';
 
 import {checkInputColumn, multipleSequenceAlignmentAny} from '../package';
 import {UNITS} from 'datagrok-api/dg';
-import {ALPHABET, UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 
 category('checkInputColumn', () => {
@@ -27,7 +28,7 @@ seq4`;
     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);
+    col.setTag(bio.TAGS.alphabet, bio.ALPHABET.DNA);
 
     const [res, msg]: [boolean, string] = checkInputColumn(
       col, 'Test', ['fasta',], ['DNA', 'RNA', 'PT']);
@@ -40,8 +41,8 @@ seq4`;
     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');
+    col.setTag(bio.TAGS.alphabetSize, '11');
+    col.setTag(bio.TAGS.alphabetIsMultichar, 'true');
 
     const [res, msg]: [boolean, string] = checkInputColumn(
       col, 'Test', ['fasta',], ['DNA', 'RNA', 'PT']);
@@ -54,9 +55,9 @@ seq4`;
     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');
+    col.setTag(bio.TAGS.alphabet, 'UN');
+    col.setTag(bio.TAGS.alphabetSize, '11');
+    col.setTag(bio.TAGS.alphabetIsMultichar, 'true');
 
     const [res, msg]: [boolean, string] = checkInputColumn(
       col, 'Test', ['fasta',], ['DNA', 'RNA', 'PT']);

package/src/tests/convert-test.ts

@@ -1,12 +1,11 @@
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
+import * as bio from '@datagrok-libraries/bio';
 
 import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
 
 import {ConverterFunc} from './types';
-import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
-import {NOTATION, UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 // import {mmSemType} from '../const';
 // import {importFasta} from '../package';
@@ -133,12 +132,12 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
     return _csvDfs[key];
   };
 
-  function converter(tgtNotation: NOTATION, tgtSeparator: string | null = null): ConverterFunc {
-    if (tgtNotation === NOTATION.SEPARATOR && !tgtSeparator)
+  function converter(tgtNotation: bio.NOTATION, tgtSeparator: string | null = null): ConverterFunc {
+    if (tgtNotation === bio.NOTATION.SEPARATOR && !tgtSeparator)
       throw new Error(`Argument 'separator' is missed for notation '${tgtNotation.toString()}'.`);
 
     return function(srcCol: DG.Column): DG.Column {
-      const converter = new NotationConverter(srcCol);
+      const converter = new bio.NotationConverter(srcCol);
       const resCol = converter.convert(tgtNotation, tgtSeparator);
       expect(resCol.getTag('units'), tgtNotation);
       return resCol;
@@ -157,100 +156,100 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
     const tgtCol: DG.Column = tgtDf.getCol('seq');
 
     expectArray(resCol.toList(), tgtCol.toList());
-    const uh: UnitsHandler = new UnitsHandler(resCol);
+    const uh: bio.UnitsHandler = new bio.UnitsHandler(resCol);
   }
 
   // FASTA tests
   // fasta -> separator
   test('testFastaPtToSeparator', async () => {
-    await _testConvert(Samples.fastaPt, converter(NOTATION.SEPARATOR, '-'), Samples.separatorPt);
+    await _testConvert(Samples.fastaPt, converter(bio.NOTATION.SEPARATOR, '-'), Samples.separatorPt);
   });
   test('testFastaDnaToSeparator', async () => {
-    await _testConvert(Samples.fastaDna, converter(NOTATION.SEPARATOR, '/'), Samples.separatorDna);
+    await _testConvert(Samples.fastaDna, converter(bio.NOTATION.SEPARATOR, '/'), Samples.separatorDna);
   });
   test('testFastaRnaToSeparator', async () => {
-    await _testConvert(Samples.fastaRna, converter(NOTATION.SEPARATOR, '*'), Samples.separatorRna);
+    await _testConvert(Samples.fastaRna, converter(bio.NOTATION.SEPARATOR, '*'), Samples.separatorRna);
   });
   test('testFastaGapsToSeparator', async () => {
-    await _testConvert(Samples.fastaGaps, converter(NOTATION.SEPARATOR, '/'), Samples.separatorGaps);
+    await _testConvert(Samples.fastaGaps, converter(bio.NOTATION.SEPARATOR, '/'), Samples.separatorGaps);
   });
 
   // fasta -> helm
   test('testFastaPtToHelm', async () => {
-    await _testConvert(Samples.fastaPt, converter(NOTATION.HELM), Samples.helmPt);
+    await _testConvert(Samples.fastaPt, converter(bio.NOTATION.HELM), Samples.helmPt);
   });
   test('testFastaDnaToHelm', async () => {
-    await _testConvert(Samples.fastaDna, converter(NOTATION.HELM), Samples.helmDna);
+    await _testConvert(Samples.fastaDna, converter(bio.NOTATION.HELM), Samples.helmDna);
   });
   test('testFastaRnaToHelm', async () => {
-    await _testConvert(Samples.fastaRna, converter(NOTATION.HELM), Samples.helmRna);
+    await _testConvert(Samples.fastaRna, converter(bio.NOTATION.HELM), Samples.helmRna);
   });
   test('testFastaGapsToHelm', async () => {
-    await _testConvert(Samples.fastaGaps, converter(NOTATION.HELM), Samples.helmGaps);
+    await _testConvert(Samples.fastaGaps, converter(bio.NOTATION.HELM), Samples.helmGaps);
   });
 
 
   // SEPARATOR tests
   // separator -> fasta
   test('testSeparatorPtToFasta', async () => {
-    await _testConvert(Samples.separatorPt, converter(NOTATION.FASTA), Samples.fastaPt);
+    await _testConvert(Samples.separatorPt, converter(bio.NOTATION.FASTA), Samples.fastaPt);
   });
   test('testSeparatorDnaToFasta', async () => {
-    await _testConvert(Samples.separatorDna, converter(NOTATION.FASTA), Samples.fastaDna);
+    await _testConvert(Samples.separatorDna, converter(bio.NOTATION.FASTA), Samples.fastaDna);
   });
   test('testSeparatorRnaToFasta', async () => {
-    await _testConvert(Samples.separatorRna, converter(NOTATION.FASTA), Samples.fastaRna);
+    await _testConvert(Samples.separatorRna, converter(bio.NOTATION.FASTA), Samples.fastaRna);
   });
   test('testSeparatorGapsToFasta', async () => {
-    await _testConvert(Samples.separatorGaps, converter(NOTATION.FASTA), Samples.fastaGaps);
+    await _testConvert(Samples.separatorGaps, converter(bio.NOTATION.FASTA), Samples.fastaGaps);
   });
 
   // separator -> helm
   test('testSeparatorPtToHelm', async () => {
-    await _testConvert(Samples.separatorPt, converter(NOTATION.HELM), Samples.helmPt);
+    await _testConvert(Samples.separatorPt, converter(bio.NOTATION.HELM), Samples.helmPt);
   });
   test('testSeparatorDnaToHelm', async () => {
-    await _testConvert(Samples.separatorDna, converter(NOTATION.HELM), Samples.helmDna);
+    await _testConvert(Samples.separatorDna, converter(bio.NOTATION.HELM), Samples.helmDna);
   });
   test('testSeparatorRnaToHelm', async () => {
-    await _testConvert(Samples.separatorRna, converter(NOTATION.HELM), Samples.helmRna);
+    await _testConvert(Samples.separatorRna, converter(bio.NOTATION.HELM), Samples.helmRna);
   });
   test('testSeparatorGapsToHelm', async () => {
-    await _testConvert(Samples.separatorGaps, converter(NOTATION.HELM), Samples.helmGaps);
+    await _testConvert(Samples.separatorGaps, converter(bio.NOTATION.HELM), Samples.helmGaps);
   });
 
 
   // HELM tests
   // helm -> fasta
   test('testHelmDnaToFasta', async () => {
-    await _testConvert(Samples.helmDna, converter(NOTATION.FASTA), Samples.fastaDna);
+    await _testConvert(Samples.helmDna, converter(bio.NOTATION.FASTA), Samples.fastaDna);
   });
   test('testHelmRnaToFasta', async () => {
-    await _testConvert(Samples.helmRna, converter(NOTATION.FASTA), Samples.fastaRna);
+    await _testConvert(Samples.helmRna, converter(bio.NOTATION.FASTA), Samples.fastaRna);
   });
   test('testHelmPtToFasta', async () => {
-    await _testConvert(Samples.helmPt, converter(NOTATION.FASTA), Samples.fastaPt);
+    await _testConvert(Samples.helmPt, converter(bio.NOTATION.FASTA), Samples.fastaPt);
   });
 
   // helm -> separator
   test('testHelmDnaToSeparator', async () => {
-    await _testConvert(Samples.helmDna, converter(NOTATION.SEPARATOR, '/'), Samples.separatorDna);
+    await _testConvert(Samples.helmDna, converter(bio.NOTATION.SEPARATOR, '/'), Samples.separatorDna);
   });
   test('testHelmRnaToSeparator', async () => {
-    await _testConvert(Samples.helmRna, converter(NOTATION.SEPARATOR, '*'), Samples.separatorRna);
+    await _testConvert(Samples.helmRna, converter(bio.NOTATION.SEPARATOR, '*'), Samples.separatorRna);
   });
   test('testHelmPtToSeparator', async () => {
-    await _testConvert(Samples.helmPt, converter(NOTATION.SEPARATOR, '-'), Samples.separatorPt);
+    await _testConvert(Samples.helmPt, converter(bio.NOTATION.SEPARATOR, '-'), Samples.separatorPt);
   });
 
   // helm miscellaneous
   test('testHelmLoneRibose', async () => {
-    await _testConvert(Samples.helmLoneRibose, converter(NOTATION.FASTA), Samples.fastaRna);
+    await _testConvert(Samples.helmLoneRibose, converter(bio.NOTATION.FASTA), Samples.fastaRna);
   });
   test('testHelmLoneDeoxyribose', async () => {
-    await _testConvert(Samples.helmLoneDeoxyribose, converter(NOTATION.SEPARATOR, '/'), Samples.separatorDna);
+    await _testConvert(Samples.helmLoneDeoxyribose, converter(bio.NOTATION.SEPARATOR, '/'), Samples.separatorDna);
   });
   test('testHelmLonePhosphorus', async () => {
-    await _testConvert(Samples.helmLonePhosphorus, converter(NOTATION.FASTA), Samples.fastaRna);
+    await _testConvert(Samples.helmLonePhosphorus, converter(bio.NOTATION.FASTA), Samples.fastaRna);
   });
 });

package/src/tests/detectors-test.ts

@@ -1,8 +1,9 @@
-import {after, before, category, test, expect, expectObject} 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 * as bio from '@datagrok-libraries/bio';
+
+import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
 
 import {importFasta} from '../package';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
@@ -400,10 +401,10 @@ export async function _testPos(
 
   expect(col.semType === DG.SEMTYPE.MACROMOLECULE, true);
   expect(col.getTag(DG.TAGS.UNITS), units);
-  expect(col.getTag(UnitsHandler.TAGS.aligned), aligned);
-  expect(col.getTag(UnitsHandler.TAGS.alphabet), alphabet);
+  expect(col.getTag(bio.TAGS.aligned), aligned);
+  expect(col.getTag(bio.TAGS.alphabet), alphabet);
   if (separator)
-    expect(col.getTag(UnitsHandler.TAGS.separator), separator);
+    expect(col.getTag(bio.TAGS.separator), separator);
 
   const uh = new UnitsHandler(col);
   expect(uh.getAlphabetSize(), alphabetSize);

package/src/tests/renderers-test.ts

@@ -1,10 +1,11 @@
-import {after, before, category, delay, expect, test} from '@datagrok-libraries/utils/src/test';
-
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
+import * as bio from '@datagrok-libraries/bio';
+
+import {after, before, category, delay, expect, test} from '@datagrok-libraries/utils/src/test';
+
 import {importFasta, multipleSequenceAlignmentAny} from '../package';
 import {convertDo} from '../utils/convert';
-import {ALPHABET, NOTATION, UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {SEM_TYPES, TAGS} from '../utils/constants';
 import {generateLongSequence, generateManySequences, performanceTest} from './test-sequnces-generators';
 
@@ -137,22 +138,22 @@ category('renderers', () => {
       `semType="${srcSeqCol!.semType}", units="${srcSeqCol!.getTag(DG.TAGS.UNITS)}", ` +
       `cell.renderer="${srcSeqCol!.getTag(DG.TAGS.CELL_RENDERER)}"`);
     expect(srcSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
-    expect(srcSeqCol.getTag(DG.TAGS.UNITS), NOTATION.FASTA);
-    expect(srcSeqCol.getTag(UnitsHandler.TAGS.aligned), 'SEQ');
-    expect(srcSeqCol.getTag(UnitsHandler.TAGS.alphabet), ALPHABET.PT);
+    expect(srcSeqCol.getTag(DG.TAGS.UNITS), bio.NOTATION.FASTA);
+    expect(srcSeqCol.getTag(bio.TAGS.aligned), 'SEQ');
+    expect(srcSeqCol.getTag(bio.TAGS.alphabet), bio.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), NOTATION.FASTA);
-    expect(msaSeqCol.getTag(UnitsHandler.TAGS.aligned), 'SEQ.MSA');
-    expect(msaSeqCol.getTag(UnitsHandler.TAGS.alphabet), ALPHABET.PT);
+    expect(msaSeqCol.getTag(DG.TAGS.UNITS), bio.NOTATION.FASTA);
+    expect(msaSeqCol.getTag(bio.TAGS.aligned), 'SEQ.MSA');
+    expect(msaSeqCol.getTag(bio.TAGS.alphabet), bio.ALPHABET.PT);
     expect(msaSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
     // check newColumn with UnitsHandler constructor
-    const uh: UnitsHandler = new UnitsHandler(msaSeqCol);
+    const uh: bio.UnitsHandler = new bio.UnitsHandler(msaSeqCol);
 
     dfList.push(df);
     tvList.push(tv);
@@ -174,13 +175,13 @@ category('renderers', () => {
     tvList.push(tv);
     dfList.push(df);
 
-    const tgtCol: DG.Column = await convertDo(srcCol, NOTATION.SEPARATOR, '/');
+    const tgtCol: DG.Column = await convertDo(srcCol, bio.NOTATION.SEPARATOR, '/');
 
     const resCellRenderer = tgtCol.getTag(DG.TAGS.CELL_RENDERER);
     expect(resCellRenderer, 'sequence');
 
     // check tgtCol with UnitsHandler constructor
-    const uh: UnitsHandler = new UnitsHandler(tgtCol);
+    const uh: bio.UnitsHandler = new bio.UnitsHandler(tgtCol);
   }
 
   async function _selectRendererBySemType() {

package/src/utils/cell-renderer.ts

@@ -7,23 +7,6 @@ import * as C from './constants';
 const undefinedColor = 'rgb(100,100,100)';
 const monomerToShortFunction: (amino: string, maxLengthOfMonomer: number) => string = bio.monomerToShort;
 
-
-function getPaletteByType(paletteType: string): bio.SeqPalette {
-  switch (paletteType) {
-  case 'PT':
-    return bio.AminoacidsPalettes.GrokGroups;
-  case 'NT':
-    return bio.NucleotidesPalettes.Chromatogram;
-  case 'DNA':
-    return bio.NucleotidesPalettes.Chromatogram;
-  case 'RNA':
-    return bio.NucleotidesPalettes.Chromatogram;
-    // other
-  default:
-    return bio.UnknownSeqPalettes.Color;
-  }
-}
-
 function getUpdatedWidth(grid: DG.Grid | null, g: CanvasRenderingContext2D, x: number, w: number): number {
   return grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
 }
@@ -61,7 +44,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
   }
 
   onMouseMove(gridCell: DG.GridCell, e: MouseEvent): void {
-    if (gridCell.cell.column.getTag(bio.UnitsHandler.TAGS.aligned) !== 'SEQ.MSA')
+    if (gridCell.cell.column.getTag(bio.TAGS.aligned) !== 'SEQ.MSA')
       return;
 
     const maxLengthWordsSum = gridCell.cell.column.temp['bio-sum-maxLengthWords'];
@@ -126,7 +109,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     //TODO: can this be replaced/merged with splitSequence?
     const units = gridCell.cell.column.getTag(DG.TAGS.UNITS);
 
-    const palette = getPaletteByType(paletteType);
+    const palette = bio.getPaletteByType(paletteType);
 
     const separator = gridCell.cell.column.getTag('separator') ?? '';
     const splitLimit = gridCell.bounds.width / 5;
@@ -227,8 +210,10 @@ export class MonomerCellRenderer extends DG.GridCellRenderer {
     g.textBaseline = 'middle';
     g.textAlign = 'center';
 
-    const palette = getPaletteByType(gridCell.cell.column.getTag(C.TAGS.ALPHABET));
-    const s: string = gridCell.cell.value || '-';
+    const palette = bio.getPaletteByType(gridCell.cell.column.getTag(C.TAGS.ALPHABET));
+    const s: string = gridCell.cell.value;
+    if (!s)
+      return;
     const color = palette.get(s);
 
     g.fillStyle = color;
@@ -271,7 +256,7 @@ export class MacromoleculeDifferenceCellRenderer extends DG.GridCellRenderer {
     const splitter = bio.getSplitter(units, separator);
     const subParts1 = splitter(s1);
     const subParts2 = splitter(s2);
-    drawMoleculeDifferenceOnCanvas(g, x, y, w, h, subParts1, subParts2, units, separator);
+    drawMoleculeDifferenceOnCanvas(g, x, y, w, h, subParts1, subParts2, units);
   }
 }
 
@@ -312,7 +297,7 @@ export function drawMoleculeDifferenceOnCanvas(
 
   let palette: bio.SeqPalette = bio.UnknownSeqPalettes.Color;
   if (units != 'HELM')
-    palette = getPaletteByType(units.substring(units.length - 2));
+    palette = bio.getPaletteByType(units.substring(units.length - 2));
 
   const vShift = 7;
   for (let i = 0; i < subParts1.length; i++) {

package/src/utils/multiple-sequence-alignment.ts

@@ -2,6 +2,7 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+import * as bio from '@datagrok-libraries/bio';
 
 import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
 
@@ -58,14 +59,14 @@ export async function runKalign(srcCol: DG.Column, isAligned = false, unUsedName
   // units
   const srcUnits = srcCol.getTag(DG.TAGS.UNITS);
   //aligned
-  const srcAligned = srcCol.getTag(UnitsHandler.TAGS.aligned);
+  const srcAligned = srcCol.getTag(bio.TAGS.aligned);
   const tgtAligned = srcAligned + '.MSA';
   //alphabet
-  const srcAlphabet = srcCol.getTag(UnitsHandler.TAGS.alphabet);
+  const srcAlphabet = srcCol.getTag(bio.TAGS.alphabet);
 
   tgtCol.setTag(DG.TAGS.UNITS, srcUnits);
-  tgtCol.setTag(UnitsHandler.TAGS.aligned, tgtAligned);
-  tgtCol.setTag(UnitsHandler.TAGS.alphabet, srcAlphabet);
+  tgtCol.setTag(bio.TAGS.aligned, tgtAligned);
+  tgtCol.setTag(bio.TAGS.alphabet, srcAlphabet);
   tgtCol.semType = DG.SEMTYPE.MACROMOLECULE;
   return tgtCol;
 }

package/src/utils/utils.ts

@@ -19,7 +19,7 @@ export function encodeMonomers(col: DG.Column): DG.Column | null {
   let encodeSymbol = MONOMER_ENCODE_MIN;
   const monomerSymbolDict: { [key: string]: number } = {};
   const units = col.tags[DG.TAGS.UNITS];
-  const sep = col.getTag(UnitsHandler.TAGS.separator);
+  const sep = col.getTag(bio.TAGS.separator);
   const splitterFunc: bio.SplitterFunc = bio.getSplitter(units, sep);
   const encodedStringArray = [];
   for (let i = 0; i < col.length; ++i) {