@datagrok/bio 2.11.41 → 2.12.0

package/package.json

@@ -2,10 +2,10 @@
   "name": "@datagrok/bio",
   "friendlyName": "Bio",
   "author": {
-    "name": "Leonid Stolbov",
-    "email": "lstolbov@datagrok.ai"
+    "name": "Aleksandr Tanas",
+    "email": "atanas@datagrok.ai"
   },
-  "version": "2.11.41",
+  "version": "2.12.0",
   "description": "Bioinformatics support (import/export of sequences, conversion, visualization, analysis). [See more](https://github.com/datagrok-ai/public/blob/master/packages/Bio/README.md) for details.",
   "repository": {
     "type": "git",
@@ -34,10 +34,10 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "5.39.29",
-    "@datagrok-libraries/chem-meta": "^1.2.1",
-    "@datagrok-libraries/ml": "^6.4.10",
-    "@datagrok-libraries/tutorials": "^1.3.11",
+    "@datagrok-libraries/bio": "5.40.0",
+    "@datagrok-libraries/chem-meta": "^1.2.3",
+    "@datagrok-libraries/ml": "^6.4.12",
+    "@datagrok-libraries/tutorials": "^1.3.12",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
     "@datagrok-libraries/utils": "^4.1.44",
@@ -54,9 +54,9 @@
     "wu": "latest"
   },
   "devDependencies": {
-    "@datagrok/chem": "^1.8.11",
-    "@datagrok/dendrogram": "^1.2.22",
-    "@datagrok/helm": "^2.1.27",
+    "@datagrok/chem": "^1.9.0",
+    "@datagrok/dendrogram": "^1.2.27",
+    "@datagrok/helm": "^2.1.30",
     "@types/node": "^17.0.24",
     "@types/wu": "latest",
     "@typescript-eslint/eslint-plugin": "latest",

package/src/analysis/sequence-activity-cliffs.ts

@@ -2,13 +2,15 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import wu from 'wu';
+
 import {ITooltipAndPanelParams} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {getSimilarityFromDistance} from '@datagrok-libraries/ml/src/distance-metrics-methods';
 import {AvailableMetrics, DistanceMetricsSubjects, StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
 import {drawMoleculeDifferenceOnCanvas} from '../utils/cell-renderer';
 import {invalidateMols, MONOMERIC_COL_TAGS} from '../substructure-search/substructure-search';
 import {TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 
 export async function getDistances(col: DG.Column, seq: string): Promise<Array<number>> {
@@ -97,19 +99,16 @@ export function createPropPanelElement(params: ITooltipAndPanelParams): HTMLDivE
 
   propPanel.append(ui.divText(params.seqCol.name, {style: {fontWeight: 'bold'}}));
 
-  const sequencesArray = new Array<string>(2);
   const activitiesArray = new Array<number>(2);
   params.points.forEach((molIdx, idx) => {
-    sequencesArray[idx] = params.seqCol.get(molIdx);
     activitiesArray[idx] = params.activityCol.get(molIdx);
   });
 
   const molDifferences: { [key: number]: HTMLCanvasElement } = {};
-  const uh = UnitsHandler.getOrCreate(params.seqCol);
-  const splitter = uh.getSplitter();
-  const subParts1 = splitter(sequencesArray[0]);
-  const subParts2 = splitter(sequencesArray[1]);
-  const canvas = createDifferenceCanvas(subParts1, subParts2, uh.units, molDifferences);
+  const sh = SeqHandler.forColumn(params.seqCol);
+  const subParts1 = sh.getSplitted(params.points[0]); // splitter(sequencesArray[0], {uh, rowIdx: -1});
+  const subParts2 = sh.getSplitted(params.points[1]); // splitter(sequencesArray[1], {uh, rowIdx: -1});
+  const canvas = createDifferenceCanvas(subParts1, subParts2, sh.units, molDifferences);
   propPanel.append(ui.div(canvas, {style: {width: '300px', overflow: 'scroll'}}));
 
   propPanel.append(createDifferencesWithPositions(molDifferences));
@@ -135,7 +134,8 @@ export function createDifferenceCanvas(
   const canvas = document.createElement('canvas');
   const context = canvas.getContext('2d');
   canvas.height = 30;
-  drawMoleculeDifferenceOnCanvas(context!, 0, 0, 0, 30, subParts1, subParts2, units, true, molDifferences);
+  drawMoleculeDifferenceOnCanvas(context!, 0, 0, 0, 30,
+    wu(subParts1.canonicals).toArray(), wu(subParts2.canonicals).toArray(), units, true, molDifferences);
   return canvas;
 }
 

package/src/analysis/sequence-diversity-viewer.ts

@@ -7,7 +7,7 @@ import {SequenceSearchBaseViewer} from './sequence-search-base-viewer';
 import {getMonomericMols} from '../calculations/monomerLevelMols';
 import {updateDivInnerHTML} from '../utils/ui-utils';
 import {Subject} from 'rxjs';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {getEncodedSeqSpaceCol} from './sequence-space';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {DistanceMatrixService, dmLinearIndex} from '@datagrok-libraries/ml/src/distance-matrix';
@@ -29,8 +29,8 @@ export class SequenceDiversityViewer extends SequenceSearchBaseViewer {
       return;
     if (this.dataFrame) {
       if (computeData && this.moleculeColumn) {
-        const uh = UnitsHandler.getOrCreate(this.moleculeColumn);
-        await (uh.isFasta() ? this.computeByMM() : this.computeByChem());
+        const sh = SeqHandler.forColumn(this.moleculeColumn);
+        await (sh.isFasta() ? this.computeByMM() : this.computeByChem());
 
         const diverseColumnName: string = this.diverseColumnLabel != null ? this.diverseColumnLabel :
           `diverse (${this.moleculeColumnName})`;

package/src/analysis/sequence-search-base-viewer.ts

@@ -14,7 +14,7 @@ export class SequenceSearchBaseViewer extends DG.JsViewer {
   fingerprint: string;
   metricsProperties = ['distanceMetric', 'fingerprint'];
   fingerprintChoices = ['Morgan', 'Pattern'];
-  moleculeColumn?: DG.Column | null;
+  moleculeColumn?: DG.Column<string>;
   moleculeColumnName: string;
   initialized: boolean = false;
   tags = [DG.TAGS.UNITS, bioTAGS.aligned, bioTAGS.separator, bioTAGS.alphabet];
@@ -51,7 +51,7 @@ export class SequenceSearchBaseViewer extends DG.JsViewer {
         .subscribe((_: any) => this.render(false)));
       this.subs.push(DG.debounce(ui.onSizeChanged(this.root), 50)
         .subscribe((_: any) => this.render(false)));
-      this.moleculeColumn = this.dataFrame.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
+      this.moleculeColumn = this.dataFrame.columns.bySemType(DG.SEMTYPE.MACROMOLECULE) as DG.Column<string>;
       this.moleculeColumnName = this.moleculeColumn?.name!;
       this.getProperty('limit')!.fromOptions({min: 1, max: this.dataFrame.rowCount});
     }

package/src/analysis/sequence-similarity-viewer.ts

@@ -7,7 +7,7 @@ import {getMonomericMols} from '../calculations/monomerLevelMols';
 import {createDifferenceCanvas, createDifferencesWithPositions} from './sequence-activity-cliffs';
 import {updateDivInnerHTML} from '../utils/ui-utils';
 import {Subject} from 'rxjs';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {alignSequencePair} from '@datagrok-libraries/bio/src/utils/macromolecule/alignment';
 import {KnnResult, SparseMatrixService} from '@datagrok-libraries/ml/src/distance-matrix/sparse-matrix-service';
 import {getEncodedSeqSpaceCol} from './sequence-space';
@@ -50,9 +50,9 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
       this.curIdx = this.dataFrame!.currentRowIdx == -1 ? 0 : this.dataFrame!.currentRowIdx;
       if (computeData && !this.gridSelect) {
         this.targetMoleculeIdx = this.dataFrame!.currentRowIdx == -1 ? 0 : this.dataFrame!.currentRowIdx;
-        const uh = UnitsHandler.getOrCreate(this.moleculeColumn!);
+        const sh = SeqHandler.forColumn(this.moleculeColumn!);
 
-        await (!uh.isHelm() ? this.computeByMM() : this.computeByChem());
+        await (!sh.isHelm() ? this.computeByMM() : this.computeByChem());
         const similarColumnName: string = this.similarColumnLabel != null ? this.similarColumnLabel :
           `similar (${this.moleculeColumnName})`;
         this.molCol = DG.Column.string(similarColumnName,
@@ -121,13 +121,13 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
     const propPanel = ui.div();
     const molDifferences: { [key: number]: HTMLCanvasElement } = {};
     const molColName = this.molCol?.name!;
-    const col = resDf.col(molColName)!;
-    const uh = UnitsHandler.getOrCreate(col);
-    const splitter = uh.getSplitter();
-    const subParts1 = splitter(this.moleculeColumn!.get(this.targetMoleculeIdx));
-    const subParts2 = splitter(resDf.get(molColName, resDf.currentRowIdx));
-    const alignment = alignSequencePair(Array.from(subParts1), Array.from(subParts2));
-    const canvas = createDifferenceCanvas(alignment.seq1Splitted, alignment.seq2Splitted, uh.units, molDifferences);
+    const resCol: DG.Column<string> = resDf.col(molColName)!;
+    const molColSh = SeqHandler.forColumn(this.moleculeColumn!);
+    const resSh = SeqHandler.forColumn(resCol);
+    const subParts1 = molColSh.getSplitted(this.targetMoleculeIdx);
+    const subParts2 = resSh.getSplitted(resDf.currentRowIdx);
+    const alignment = alignSequencePair(subParts1, subParts2);
+    const canvas = createDifferenceCanvas(alignment.seq1Splitted, alignment.seq2Splitted, resSh.units, molDifferences);
     propPanel.append(ui.div(canvas, {style: {width: '300px', overflow: 'scroll'}}));
     if (subParts1.length !== subParts2.length) {
       propPanel.append(ui.divV([

package/src/analysis/sequence-space.ts

@@ -1,8 +1,10 @@
+import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+
 import {BitArrayMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {mmDistanceFunctionArgs} from '@datagrok-libraries/ml/src/macromolecule-distance-functions/types';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {getMonomerSubstitutionMatrix} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 
@@ -13,32 +15,35 @@ export interface ISequenceSpaceResult {
 
 export async function getEncodedSeqSpaceCol(
   seqCol: DG.Column, similarityMetric: BitArrayMetrics | MmDistanceFunctionsNames, fingerprintType: string = 'Morgan'
-): Promise<{seqList:string[], options: {[_:string]: any}}> {
-// encodes sequences using utf charachters to also support multichar and non fasta sequences
-  const ncUH = UnitsHandler.getOrCreate(seqCol);
-  const seqList = seqCol.toList();
-  const splitter = ncUH.getSplitter();
-  const seqColLength = seqList.length;
+): Promise<{ seqList: string[], options: { [_: string]: any } }> {
+// encodes sequences using utf characters to also support multichar and non fasta sequences
+  const rowCount = seqCol.length;
+  const sh = SeqHandler.forColumn(seqCol);
+  const encList = Array<string>(rowCount);
   let charCodeCounter = 36;
   const charCodeMap = new Map<string, string>();
-  for (let i = 0; i < seqColLength; i++) {
-    const seq = seqList[i];
-    if (seqList[i] === null || seqCol.isNone(i)) {
-      seqList[i] = null;
+  const seqColCats = seqCol.categories;
+  const seqColRawData = seqCol.getRawData();
+  for (let rowIdx = 0; rowIdx < rowCount; rowIdx++) {
+    const catI = seqColRawData[rowIdx];
+    const seq = seqColCats[catI];
+    if (seq === null || seqCol.isNone(rowIdx)) {
+      // @ts-ignore
+      encList[rowIdx] = null;
       continue;
     }
-    seqList[i] = '';
-    const splittedSeq = splitter(seq);
+    encList[rowIdx] = '';
+    const splittedSeq = sh.getSplitted(rowIdx);
     for (let j = 0; j < splittedSeq.length; j++) {
-      const char = splittedSeq[j];
+      const char = splittedSeq.getCanonical(j);
       if (!charCodeMap.has(char)) {
         charCodeMap.set(char, String.fromCharCode(charCodeCounter));
         charCodeCounter++;
       }
-      seqList[i] += charCodeMap.get(char)!;
+      encList[rowIdx] += charCodeMap.get(char)!;
     }
   }
-  let options = {};
+  let options = {} as mmDistanceFunctionArgs;
   if (similarityMetric === MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE) {
     const monomers = Array.from(charCodeMap.keys());
     const monomerRes = await getMonomerSubstitutionMatrix(monomers, fingerprintType);
@@ -48,13 +53,12 @@ export async function getEncodedSeqSpaceCol(
         monomerRes.scoringMatrix[i][j] = 1 - val;
       });
     });
-    const monomerHashToMatrixMap: {[_: string]: number} = {};
+    const monomerHashToMatrixMap: { [_: string]: number } = {};
     Object.entries(monomerRes.alphabetIndexes).forEach(([key, value]) => {
       monomerHashToMatrixMap[charCodeMap.get(key)!] = value;
     });
     // sets distance function args in place.
-    options = {scoringMatrix: monomerRes.scoringMatrix,
-      alphabetIndexes: monomerHashToMatrixMap} satisfies mmDistanceFunctionArgs;
+    options = {scoringMatrix: monomerRes.scoringMatrix, alphabetIndexes: monomerHashToMatrixMap};
   } else if (similarityMetric === MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH) {
     const monomers = Array.from(charCodeMap.keys());
     const monomerRes = await getMonomerSubstitutionMatrix(monomers, fingerprintType);
@@ -64,13 +68,12 @@ export async function getEncodedSeqSpaceCol(
     //     monomerRes.scoringMatrix[i][j] = 1 - val;
     //   });
     // });
-    const monomerHashToMatrixMap: {[_: string]: number} = {};
+    const monomerHashToMatrixMap: { [_: string]: number } = {};
     Object.entries(monomerRes.alphabetIndexes).forEach(([key, value]) => {
       monomerHashToMatrixMap[charCodeMap.get(key)!] = value;
     });
     // sets distance function args in place.
-    options = {scoringMatrix: monomerRes.scoringMatrix,
-      alphabetIndexes: monomerHashToMatrixMap} satisfies mmDistanceFunctionArgs;
+    options = {scoringMatrix: monomerRes.scoringMatrix, alphabetIndexes: monomerHashToMatrixMap};
   }
-  return {seqList, options};
+  return {seqList: encList, options};
 }

package/src/calculations/monomerLevelMols.ts

@@ -5,33 +5,32 @@ import * as DG from 'datagrok-api/dg';
 import wu from 'wu';
 
 import {getHelmMonomers} from '../package';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
-import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {GAP_SYMBOL, ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 
 const V2000_ATOM_NAME_POS = 31;
 
 export async function getMonomericMols(
   mcol: DG.Column<string>, pattern: boolean = false, monomersDict?: Map<string, string>
 ): Promise<DG.Column> {
-  const uh = UnitsHandler.getOrCreate(mcol);
+  const sh = SeqHandler.forColumn(mcol);
   let molV3000Array;
   monomersDict ??= new Map();
-  const monomers = uh.isHelm() ?
-    getHelmMonomers(mcol) : Object.keys(uh.stats.freq).filter((it) => it !== '');
+  const monomers = sh.isHelm() ?
+    getHelmMonomers(mcol) : Object.keys(sh.stats.freq).filter((it) => it !== '');
 
   for (let i = 0; i < monomers.length; i++) {
     if (!monomersDict.has(monomers[i]))
       monomersDict.set(monomers[i], `${monomersDict.size + 1}`);
   }
 
-  if (uh.isHelm()) {
+  if (sh.isHelm()) {
     molV3000Array = await grok.functions.call('HELM:getMolFiles', {col: mcol});
     molV3000Array = changeV2000ToV3000(molV3000Array, monomersDict, pattern);
   } else {
     molV3000Array = new Array<string>(mcol.length);
     for (let i = 0; i < mcol.length; i++) {
-      const sequenceMonomers = wu(uh.splitted[i]).filter((it) => it !== '').toArray();
-      const molV3000 = molV3000FromNonHelmSequence(sequenceMonomers, monomersDict, pattern);
+      const molV3000 = molV3000FromNonHelmSequence(sh.getSplitted(i), monomersDict, pattern);
       molV3000Array[i] = molV3000;
     }
   }
@@ -51,9 +50,12 @@ M  V30 BEGIN CTAB
   molV3000 += 'M  V30 BEGIN ATOM\n';
 
   for (let atomRowI = 0; atomRowI < monomers.length; atomRowI++) {
-    molV3000 += pattern ?
-      `M  V30 ${atomRowI + 1} R${monomersDict.get(monomers[atomRowI])} 0.000 0.000 0 0\n` :
-      `M  V30 ${atomRowI + 1} At 0.000 0.000 0 0 MASS=${monomersDict.get(monomers[atomRowI])}\n`;
+    const cm: string = monomers.getCanonical(atomRowI);
+    if (cm !== GAP_SYMBOL) {
+      molV3000 += pattern ?
+        `M  V30 ${atomRowI + 1} R${monomersDict.get(cm)} 0.000 0.000 0 0\n` :
+        `M  V30 ${atomRowI + 1} At 0.000 0.000 0 0 MASS=${monomersDict.get(cm)}\n`;
+    }
   }
 
   molV3000 += 'M  V30 END ATOM\n';

package/src/const.ts

@@ -0,0 +1,5 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+export const GAP_SYMBOL: string = '';

package/src/package.ts

@@ -12,7 +12,7 @@ import {BitArrayMetrics, KnownMetrics} from '@datagrok-libraries/ml/src/typed-me
 import {
   TAGS as bioTAGS,
 } from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
@@ -165,11 +165,11 @@ export function getBioLib(): IMonomerLib {
   return MonomerLibManager.instance.getBioLib();
 }
 
-//name: getUnitsHandler
+//name: getSeqHandler
 //input: column sequence { semType: Macromolecule }
 //output: object result
-export function getUnitsHandler(sequence: DG.Column<string>): UnitsHandler {
-  return UnitsHandler.getOrCreate(sequence);
+export function getSeqHandler(sequence: DG.Column<string>): SeqHandler {
+  return SeqHandler.forColumn(sequence);
 }
 
 // -- Panels --
@@ -611,7 +611,7 @@ export async function compositionAnalysis(): Promise<void> {
     if (col.semType != DG.SEMTYPE.MACROMOLECULE)
       return false;
 
-    const _colUH = UnitsHandler.getOrCreate(col);
+    const _colSh = SeqHandler.forColumn(col);
     // TODO: prevent for cyclic, branched or multiple chains in Helm
     return true;
   });
@@ -630,7 +630,7 @@ export async function compositionAnalysis(): Promise<void> {
     return;
   } else if (colList.length > 1) {
     const colListNames: string [] = colList.map((col) => col.name);
-    const selectedCol = colList.find((c) => { return UnitsHandler.getOrCreate(c).isMsa(); });
+    const selectedCol = colList.find((c) => { return SeqHandler.forColumn(c).isMsa(); });
     const colInput: DG.InputBase = ui.choiceInput(
       'Column', selectedCol ? selectedCol.name : colListNames[0], colListNames);
     ui.dialog({
@@ -773,8 +773,8 @@ export async function splitToMonomersTopMenu(table: DG.DataFrame, sequence: DG.C
 //name: Bio: getHelmMonomers
 //input: column sequence {semType: Macromolecule}
 export function getHelmMonomers(sequence: DG.Column<string>): string[] {
-  const uh = UnitsHandler.getOrCreate(sequence);
-  const stats = uh.stats;
+  const sh = SeqHandler.forColumn(sequence);
+  const stats = sh.stats;
   return Object.keys(stats.freq);
 }
 

package/src/tests/WebLogo-layout-tests.ts

@@ -4,10 +4,10 @@ import * as ui from 'datagrok-api/ui';
 
 import wu from 'wu';
 
-import {category, expect, test, testViewer} from '@datagrok-libraries/utils/src/test';
+import {category, delay, expect, test} from '@datagrok-libraries/utils/src/test';
 
 import {awaitGrid} from './utils';
-import {WebLogoViewer} from '../viewers/web-logo-viewer';
+import {Debounces, WebLogoViewer} from '../viewers/web-logo-viewer';
 
 import {_package} from '../package-test';
 
@@ -20,12 +20,15 @@ category('WebLogo-layout', () => {
     const wlViewer = await df.plot.fromType('WebLogo',
       {sequenceColumnName: col.name}) as unknown as WebLogoViewer;
     view.dockManager.dock(wlViewer);
+
+    await delay(Debounces.render * 2);
     await wlViewer.awaitRendered();
     await awaitGrid(view.grid);
 
     const viewLayout = view.saveLayout();
     const viewLayoutJsonStr = viewLayout.toJson();
     view.loadLayout(viewLayout);
+    await delay(Debounces.render * 2);
     await wlViewer.awaitRendered();
     await awaitGrid(view.grid);
 

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

@@ -3,13 +3,17 @@ import * as DG from 'datagrok-api/dg';
 
 import {category, expect, expectArray, test, testEvent} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+
 import {
   countForMonomerAtPosition,
   PositionInfo as PI,
   PositionMonomerInfo as PMI,
   WebLogoViewer,
 } from '../viewers/web-logo-viewer';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+
+const g: string = GAP_SYMBOL;
 
 category('WebLogo-positions', () => {
   const csvDf1 = `seq
@@ -36,18 +40,18 @@ ATC-G-TTGC--
     const positions: PI[] = wlViewer['positions'];
 
     const resAllDf1: PI[] = [
-      new PI(0, '1', {'A': new PMI(2), '-': new PMI(3)}),
+      new PI(0, '1', {'A': new PMI(2), [g]: new PMI(3)}),
       new PI(1, '2', {'T': new PMI(5)}),
       new PI(2, '3', {'C': new PMI(5)}),
-      new PI(3, '4', {'-': new PMI(5)}),
+      new PI(3, '4', {[g]: new PMI(5)}),
       new PI(4, '5', {'G': new PMI(5)}),
-      new PI(5, '6', {'-': new PMI(3), 'C': new PMI(2)}),
+      new PI(5, '6', {[g]: new PMI(3), 'C': new PMI(2)}),
       new PI(6, '7', {'T': new PMI(5)}),
       new PI(7, '8', {'T': new PMI(5)}),
       new PI(8, '9', {'G': new PMI(5)}),
       new PI(9, '10', {'C': new PMI(5)}),
-      new PI(10, '11', {'-': new PMI(5)}),
-      new PI(11, '12', {'-': new PMI(5)}),
+      new PI(10, '11', {[g]: new PMI(5)}),
+      new PI(11, '12', {[g]: new PMI(5)}),
     ];
 
     expect(positions.length, resAllDf1.length);
@@ -89,15 +93,15 @@ ATC-G-TTGC--
     const positions: PI[] = wlViewer['positions'];
 
     const resAllDf1: PI[] = [
-      new PI(0, '1', {'-': new PMI(3)}),
+      new PI(0, '1', {[g]: new PMI(3)}),
       new PI(1, '2', {'T': new PMI(3)}),
-      new PI(2, '3', {'-': new PMI(3)}),
-      new PI(3, '4', {'-': new PMI(3)}),
+      new PI(2, '3', {[g]: new PMI(3)}),
+      new PI(3, '4', {[g]: new PMI(3)}),
       new PI(4, '5', {'C': new PMI(3)}),
-      new PI(5, '6', {'-': new PMI(2), 'C': new PMI(1)}),
+      new PI(5, '6', {[g]: new PMI(2), 'C': new PMI(1)}),
       new PI(6, '7', {'G': new PMI(3)}),
       new PI(7, '8', {'T': new PMI(3)}),
-      new PI(8, '9', {'-': new PMI(3)}),
+      new PI(8, '9', {[g]: new PMI(3)}),
     ];
 
     expect(positions.length, resAllDf1.length);
@@ -128,11 +132,11 @@ ATC-G-TTGC--
     const resPosList: PI[] = wlViewer['positions'];
 
     const tgtPosList: PI[] = [
-      new PI(0, '1', {'A': new PMI(2), '-': new PMI(3)}),
+      new PI(0, '1', {'A': new PMI(2), [g]: new PMI(3)}),
       new PI(1, '2', {'T': new PMI(5)}),
       new PI(2, '3', {'C': new PMI(5)}),
       new PI(4, '5', {'G': new PMI(5)}),
-      new PI(5, '6', {'-': new PMI(3), 'C': new PMI(2)}),
+      new PI(5, '6', {[g]: new PMI(3), 'C': new PMI(2)}),
       new PI(6, '7', {'T': new PMI(5)}),
       new PI(7, '8', {'T': new PMI(5)}),
       new PI(8, '9', {'G': new PMI(5)}),
@@ -166,7 +170,7 @@ ATC-G-TTGC--
     const tgtPosList: PI[] = [
       new PI(2, '3', {'C': new PMI(5)}),
       new PI(4, '5', {'G': new PMI(5)}),
-      new PI(5, '6', {'-': new PMI(3), 'C': new PMI(2)}),
+      new PI(5, '6', {[g]: new PMI(3), 'C': new PMI(2)}),
       new PI(6, '7', {'T': new PMI(5)}),
     ];
 
@@ -178,8 +182,8 @@ ATC-G-TTGC--
     }
 
     const atPI1: PI = resPosList[1];
-    const uh = UnitsHandler.getOrCreate(seqCol);
-    const countAt1 = countForMonomerAtPosition(df, uh, df.filter, 'G', atPI1);
+    const sh = SeqHandler.forColumn(seqCol);
+    const countAt1 = countForMonomerAtPosition(df, sh, df.filter, 'G', atPI1);
     expect(countAt1, 5);
     await wlViewer.awaitRendered();
   });

package/src/tests/bio-tests.ts

@@ -4,18 +4,18 @@ import * as DG from 'datagrok-api/dg';
 
 import {category, test, expect, expectObject, expectArray} from '@datagrok-libraries/utils/src/test';
 import {
-  getAlphabetSimilarity,
-  monomerToShort,
-  pickUpPalette,
-  splitterAsFasta,
-  splitterAsHelm,
+  NOTATION, getAlphabetSimilarity, monomerToShort, pickUpPalette, splitterAsFasta, splitterAsHelm,
 } from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {Nucleotides, NucleotidesPalettes} from '@datagrok-libraries/bio/src/nucleotides';
 import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
 import {UnknownSeqPalette} from '@datagrok-libraries/bio/src/unknown';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {getStatsForCol} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
 
+import {GAP_SYMBOL} from '../const';
+
+/** GAP_SYMBOL */
+const g: string = GAP_SYMBOL;
+
 category('bio', () => {
   const csvDfN1: string = `seq
 ACGTCT
@@ -58,6 +58,8 @@ XZJ{}2
 PEPTIDE1{meI}$$$$`;
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
     const seqCol: DG.Column = df.getCol('seq')!;
+    seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    seqCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
     const stats = getStatsForCol(seqCol, 1, splitterAsHelm);
 
     expectObject(stats.freq, {
@@ -127,6 +129,8 @@ category('WebLogo.monomerToShort', () => {
 export async function _testGetStats(csvDfN1: string) {
   const dfN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
   const seqCol: DG.Column = dfN1.col('seq')!;
+  seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+  seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
   const stats = getStatsForCol(seqCol, 5, splitterAsFasta);
 
   expectObject(stats.freq, {
@@ -144,7 +148,7 @@ export async function _testGetAlphabetSimilarity() {
     'C': 3015,
     'G': 3015,
     'T': 2048,
-    '-': 1000,
+    [g]: 1000,
   };
   const alphabet: Set<string> = new Set(Object.keys(Nucleotides.Names));
   const res = getAlphabetSimilarity(freq, alphabet);
@@ -155,6 +159,8 @@ export async function _testGetAlphabetSimilarity() {
 export async function _testPickupPaletteN1(csvDfN1: string) {
   const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
   const col: DG.Column = df.col('seq')!;
+  col.semType = DG.SEMTYPE.MACROMOLECULE;
+  col.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
   const cp = pickUpPalette(col);
 
   expect(cp instanceof NucleotidesPalettes, true);
@@ -163,6 +169,8 @@ export async function _testPickupPaletteN1(csvDfN1: string) {
 export async function _testPickupPaletteN1e(csvDfN1e: string) {
   const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1e);
   const col: DG.Column = df.col('seq')!;
+  col.semType = DG.SEMTYPE.MACROMOLECULE;
+  col.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
   const cp = pickUpPalette(col);
 
   expect(cp instanceof NucleotidesPalettes, true);
@@ -171,6 +179,8 @@ export async function _testPickupPaletteN1e(csvDfN1e: string) {
 export async function _testPickupPaletteAA1(csvDfAA1: string) {
   const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfAA1);
   const col: DG.Column = df.col('seq')!;
+  col.semType = DG.SEMTYPE.MACROMOLECULE;
+  col.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
   const cp = pickUpPalette(col);
 
   expect(cp instanceof AminoacidsPalettes, true);
@@ -179,6 +189,8 @@ export async function _testPickupPaletteAA1(csvDfAA1: string) {
 export async function _testPickupPaletteX(csvDfX: string) {
   const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfX);
   const col: DG.Column = df.col('seq')!;
+  col.semType = DG.SEMTYPE.MACROMOLECULE;
+  col.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
   const cp = pickUpPalette(col);
 
   expect(cp instanceof UnknownSeqPalette, true);

package/src/tests/converters-test.ts

@@ -5,7 +5,7 @@ import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src
 
 import {ConverterFunc} from './types';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
 // import {mmSemType} from '../const';
 // import {importFasta} from '../package';
@@ -133,8 +133,8 @@ RNA1{p.r(U)p.r(U)p.r(C)p.r(A)p.r(A)p.r(C)p.r(U)p.r(U)p.r(C)p.r(A)p.r(A)p.r(C)p.p
       throw new Error(`Argument 'separator' is mandatory for target notation '${tgtNotation.toString()}'.`);
 
     return function(srcCol: DG.Column): DG.Column {
-      const converterUH = UnitsHandler.getOrCreate(srcCol);
-      const resCol = converterUH.convert(tgtNotation, tgtSeparator);
+      const converterSh = SeqHandler.forColumn(srcCol);
+      const resCol = converterSh.convert(tgtNotation, tgtSeparator);
       expect(resCol.getTag(DG.TAGS.UNITS), tgtNotation);
       return resCol;
     };
@@ -152,7 +152,7 @@ RNA1{p.r(U)p.r(U)p.r(C)p.r(A)p.r(A)p.r(C)p.r(U)p.r(U)p.r(C)p.r(A)p.r(A)p.r(C)p.p
     const tgtCol: DG.Column = tgtDf.getCol('seq');
 
     expectArray(resCol.toList(), tgtCol.toList());
-    const _uh: UnitsHandler = UnitsHandler.getOrCreate(resCol);
+    const _sh: SeqHandler = SeqHandler.forColumn(resCol);
   }
 
   // FASTA tests