@datagrok/bio 2.0.19 → 2.0.21

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.0.19",
+  "version": "2.0.21",
   "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.1",
     "@datagrok-libraries/chem-meta": "1.0.1",
     "@datagrok-libraries/ml": "^6.2.0",
     "@datagrok-libraries/utils": "^1.10.1",

package/src/package.ts

@@ -450,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);
@@ -519,6 +519,7 @@ export function bioSubstructureSearch(col: DG.Column): void {
 export function saveAsFasta() {
   saveAsFastaUI();
 }
+
 //name: BioSubstructureFilter
 //description: Substructure filter for linear macromolecules
 //tags: filter

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

@@ -1,7 +1,8 @@
 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';
@@ -30,14 +31,14 @@ export function substructureSearchDialog(col: DG.Column): void {
   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, NOTATION.HELM);
+  df.col('substr_helm')!.setTag(DG.TAGS.UNITS, bio.NOTATION.HELM);
   const grid = df.plot.grid();
   const separatorInput = ui.textInput('Separator', separator);
 
   const inputsDiv = ui.div();
 
-  const inputs = units === NOTATION.HELM ? ui.divV([editHelmLink]) :
-    units === NOTATION.SEPARATOR ? ui.inputs([substructureInput, separatorInput]) :
+  const inputs = units === bio.NOTATION.HELM ? ui.divV([editHelmLink]) :
+    units === bio.NOTATION.SEPARATOR ? ui.inputs([substructureInput, separatorInput]) :
       ui.inputs([substructureInput]);
 
   updateDivInnerHTML(inputsDiv, inputs);
@@ -48,15 +49,15 @@ export function substructureSearchDialog(col: DG.Column): void {
       inputsDiv
     ]))
     .onOK(async () => {
-      let substructure = units === NOTATION.HELM ? df.get('substr_helm', 0) : substructureInput.value;
-      if (units === NOTATION.SEPARATOR && separatorInput.value !== separator && separatorInput.value !== '')
+      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) {
         let matches: BitSet;
-        if (units === NOTATION.HELM)
+        if (units === bio.NOTATION.HELM)
           matches = await helmSubstructureSearch(substructure, col);
         else
           matches = linearSubstructureSearch(substructure, col);
@@ -80,7 +81,7 @@ export function linearSubstructureSearch(substructure: string, col: DG.Column):
 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, NOTATION.HELM);
+  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]);

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,7 +210,7 @@ export class MonomerCellRenderer extends DG.GridCellRenderer {
     g.textBaseline = 'middle';
     g.textAlign = 'center';
 
-    const palette = getPaletteByType(gridCell.cell.column.getTag(C.TAGS.ALPHABET));
+    const palette = bio.getPaletteByType(gridCell.cell.column.getTag(C.TAGS.ALPHABET));
     const s: string = gridCell.cell.value;
     if (!s)
       return;
@@ -314,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) {

package/src/viewers/vd-regions-viewer.ts

@@ -110,10 +110,8 @@ export class VdRegionsViewer extends DG.JsViewer implements bio.IVdRegionsViewer
     await this.buildView();
   }
 
-  public override onTableAttached() {
-    window.setTimeout(async () => {
-      await this.init();
-    }, 0 /* next event cycle */);
+  public override async onTableAttached() {
+    await this.init();
   }
 
   public override async onPropertyChanged(property: DG.Property | null) {

package/src/widgets/bio-substructure-filter.ts

@@ -6,10 +6,11 @@
 
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+import * as bio from '@datagrok-libraries/bio';
+
 import wu from 'wu';
 import {linearSubstructureSearch} from '../substructure-search/substructure-search';
 import {Subject, Subscription} from 'rxjs';
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/units-handler';
 import * as C from '../utils/constants';
 
 export class BioSubstructureFilter extends DG.Filter {
@@ -19,6 +20,7 @@ export class BioSubstructureFilter extends DG.Filter {
   onBioFilterChangedSubs?: Subscription;
 
   get calculating(): boolean { return this.loader.style.display == 'initial'; }
+
   set calculating(value: boolean) { this.loader.style.display = value ? 'initial' : 'none'; }
 
   get filterSummary(): string {
@@ -44,7 +46,7 @@ export class BioSubstructureFilter extends DG.Filter {
     this.column = dataFrame.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
     this.columnName = this.column?.name;
     const notation = this.column?.getTag(DG.TAGS.UNITS);
-    this.bioFilter = notation === NOTATION.FASTA ?
+    this.bioFilter = notation === bio.NOTATION.FASTA ?
       new FastaFilter() : new SeparatorFilter(this.column!.getTag(C.TAGS.SEPARATOR));
     this.root.appendChild(this.bioFilter!.filterPanel);
     this.root.appendChild(this.loader);
@@ -82,10 +84,10 @@ export class BioSubstructureFilter extends DG.Filter {
   }
 
   /**
-    * Performs the actual filtering
-    * When the results are ready, triggers `rows.requestFilter`, which in turn triggers `applyFilter`
-    * that would simply apply the bitset synchronously.
-    */
+   * Performs the actual filtering
+   * When the results are ready, triggers `rows.requestFilter`, which in turn triggers `applyFilter`
+   * that would simply apply the bitset synchronously.
+   */
   async _onInputChanged(): Promise<void> {
     if (!this.isFiltering) {
       this.bitset = null;
@@ -145,7 +147,7 @@ class SeparatorFilter extends FastaFilter {
 
   get substructure() {
     return this.separatorInput.value && this.separatorInput.value !== this.colSeparator ?
-      this.substructureInput.value.replaceAll(this.separatorInput.value, this.colSeparator):
+      this.substructureInput.value.replaceAll(this.separatorInput.value, this.colSeparator) :
       this.substructureInput.value;
   }
 }