@datagrok/bio 2.8.4 → 2.8.6

package/dockerfiles/Dockerfile

@@ -24,12 +24,12 @@ RUN savedAptMark="$(apt-mark showmanual)" ; \
     ; \
     apt-mark auto '.*' > /dev/null ; \
     [ -z "$savedAptMark" ] || apt-mark manual $savedAptMark ; \
-	wget https://mafft.cbrc.jp/alignment/software/mafft_7.520-1_amd64.deb -O mafft.deb; \
-	apt install -y ./mafft.deb; \
-	rm -rf mafft.deb; \
+    wget https://mafft.cbrc.jp/alignment/software/mafft_7.520-1_amd64.deb -O mafft.deb; \
+    apt install -y ./mafft.deb; \
+    rm -rf mafft.deb; \
     wget https://github.com/Merck/PepSeA/archive/refs/heads/main.zip -O PepSeA.zip; \
     unzip -q PepSeA.zip -d /opt ; \
-	rm -rf PepSeA.zip; \
+    rm -rf PepSeA.zip; \
     chown -R grok:grok /opt/PepSeA-main ; \
     apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false ; \
     apt-get clean ; \
@@ -57,6 +57,7 @@ def distout():\n\
 \n\
     return distout_output\n' >> /opt/PepSeA-main/alignment/api.py;
 
+# It is important to run docker container as user and not as root
 USER grok:grok
 
 # Command source does not work for Docker, cause it will apply only to one layer

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.8.4",
+  "version": "2.8.6",
   "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,7 +34,7 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.34.3",
+    "@datagrok-libraries/bio": "^5.36.0",
     "@datagrok-libraries/chem-meta": "^1.0.1",
     "@datagrok-libraries/ml": "^6.3.39",
     "@datagrok-libraries/tutorials": "^1.3.6",

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

@@ -7,7 +7,9 @@ import {getSimilarityFromDistance} from '@datagrok-libraries/ml/src/distance-met
 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 {getSplitter, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 
 export async function getDistances(col: DG.Column, seq: string): Promise<Array<number>> {
   const stringArray = col.toList();
@@ -103,12 +105,11 @@ export function createPropPanelElement(params: ITooltipAndPanelParams): HTMLDivE
   });
 
   const molDifferences: { [key: number]: HTMLCanvasElement } = {};
-  const units = params.seqCol.getTag(DG.TAGS.UNITS);
-  const separator = params.seqCol.getTag(bioTAGS.separator);
-  const splitter = getSplitter(units, separator);
+  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, units, molDifferences);
+  const canvas = createDifferenceCanvas(subParts1, subParts2, uh.units, molDifferences);
   propPanel.append(ui.div(canvas, {style: {width: '300px', overflow: 'scroll'}}));
 
   propPanel.append(createDifferencesWithPositions(molDifferences));
@@ -127,8 +128,8 @@ function createPropPanelField(name: string, value: number): HTMLDivElement {
 }
 
 export function createDifferenceCanvas(
-  subParts1: string[],
-  subParts2: string[],
+  subParts1: ISeqSplitted,
+  subParts2: ISeqSplitted,
   units: string,
   molDifferences: { [key: number]: HTMLCanvasElement }): HTMLCanvasElement {
   const canvas = document.createElement('canvas');

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

@@ -7,7 +7,6 @@ import {getMonomericMols} from '../calculations/monomerLevelMols';
 import {createDifferenceCanvas, createDifferencesWithPositions} from './sequence-activity-cliffs';
 import {updateDivInnerHTML} from '../utils/ui-utils';
 import {Subject} from 'rxjs';
-import {TAGS as bioTAGS, getSplitter} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {calcMmDistanceMatrix, dmLinearIndex} from './workers/mm-distance-worker-creator';
 import {calculateMMDistancesArray} from './workers/mm-distance-array-service';
@@ -106,9 +105,10 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
     const linearizeFunc = dmLinearIndex(len);
     // array that keeps track of the indexes and scores together
     const indexWScore = Array(len).fill(0)
-      .map((_, i) => ({idx: i, score: i === this.targetMoleculeIdx ? 1 :
-        this.preComputeDistanceMatrix ? 1 - this.mmDistanceMatrix[linearizeFunc(this.targetMoleculeIdx, i)] :
-          1 - distanceArray[i]
+      .map((_, i) => ({
+        idx: i, score: i === this.targetMoleculeIdx ? 1 :
+          this.preComputeDistanceMatrix ? 1 - this.mmDistanceMatrix[linearizeFunc(this.targetMoleculeIdx, i)] :
+            1 - distanceArray[i]
       }));
     indexWScore.sort((a, b) => b.score - a.score);
     // get the most similar molecules
@@ -122,12 +122,12 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
     const propPanel = ui.div();
     const molDifferences: { [key: number]: HTMLCanvasElement } = {};
     const molColName = this.molCol?.name!;
-    const units = resDf.col(molColName)!.getTag(DG.TAGS.UNITS);
-    const separator = resDf.col(molColName)!.getTag(bioTAGS.separator);
-    const splitter = getSplitter(units, separator);
+    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 canvas = createDifferenceCanvas(subParts1, subParts2, units, molDifferences);
+    const canvas = createDifferenceCanvas(subParts1, subParts2, uh.units, molDifferences);
     propPanel.append(ui.div(canvas, {style: {width: '300px', overflow: 'scroll'}}));
     if (subParts1.length !== subParts2.length) {
       propPanel.append(ui.divV([

package/src/apps/web-logo-app.ts

@@ -2,7 +2,12 @@ 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 {IWebLogoViewer} from '@datagrok-libraries/bio/src/viewers/web-logo';
+
+import {PROPS as wlPROPS} from '../viewers/web-logo-viewer';
+
 import {_package} from '../package';
 
 export class WebLogoApp {
@@ -11,7 +16,7 @@ export class WebLogoApp {
   df: DG.DataFrame;
   view: DG.TableView;
 
-  constructor() {}
+  constructor(private readonly urlParams: URLSearchParams) {}
 
   async init(df: DG.DataFrame, funcName: string): Promise<void> {
     this._funcName = funcName;
@@ -23,12 +28,27 @@ export class WebLogoApp {
   // -- View --
 
   async buildView(): Promise<void> {
-    this.view = grok.shell.addTableView(this.df);
-    this.view.path = this.view.basePath = `func/${_package.name}.${this._funcName}`;
+    const urlParamsTxt = wu(this.urlParams.entries())
+      .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+      .toArray().join('&');
 
-    const viewer: DG.Viewer & IWebLogoViewer = (await this.view.dataFrame.plot.fromType('WebLogo', {
-      sequenceColumnName: 'sequence',
-    }));
+    this.view = grok.shell.addTableView(this.df);
+    this.view.path = this.view.basePath = `func/${_package.name}.${this._funcName}?${urlParamsTxt}`;
+
+    const options: { [p: string]: any } = {sequenceColumnName: 'sequence'};
+    for (const [optName, optValue] of this.urlParams.entries()) {
+      switch (optName) {
+        // boolean
+        case wlPROPS.fixWidth:
+        case wlPROPS.fitArea:
+          options[optName] = ((v) => { return ['1', 'on', 'true'].includes(v.toLowerCase()); })(optValue);
+          break;
+        default:
+          options[optName] = optValue;
+      }
+    }
+    const viewer: DG.Viewer & IWebLogoViewer = (await this.view.dataFrame.plot
+      .fromType('WebLogo', options)) as DG.Viewer & IWebLogoViewer;
     this.view.dockManager.dock(viewer, DG.DOCK_TYPE.DOWN, null, 'WebLogo', 0.35);
   }
 }

package/src/calculations/monomerLevelMols.ts

@@ -1,9 +1,12 @@
 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 {getHelmMonomers} from '../package';
-import {TAGS as bioTAGS, getSplitter, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 
 const V2000_ATOM_NAME_POS = 31;
 
@@ -27,7 +30,7 @@ export async function getMonomericMols(
   } else {
     molV3000Array = new Array<string>(mcol.length);
     for (let i = 0; i < mcol.length; i++) {
-      const sequenceMonomers = uh.splitted[i].filter((it) => it !== '');
+      const sequenceMonomers = wu(uh.splitted[i]).filter((it) => it !== '').toArray();
       const molV3000 = molV3000FromNonHelmSequence(sequenceMonomers, monomersDict, pattern);
       molV3000Array[i] = molV3000;
     }
@@ -36,7 +39,7 @@ export async function getMonomericMols(
 }
 
 function molV3000FromNonHelmSequence(
-  monomers: Array<string>, monomersDict: Map<string, string>, pattern: boolean = false) {
+  monomers: ISeqSplitted, monomersDict: Map<string, string>, pattern: boolean = false) {
   let molV3000 = `
   Datagrok macromolecule handler
 

package/src/package.ts

@@ -764,7 +764,8 @@ export function bioSubstructureFilter(): BioSubstructureFilter {
 export async function webLogoLargeApp(): Promise<void> {
   const pi = DG.TaskBarProgressIndicator.create('WebLogo');
   try {
-    const app = new WebLogoApp();
+    const urlParams = new URLSearchParams(window.location.search);
+    const app = new WebLogoApp(urlParams);
     const df: DG.DataFrame = await _package.files.readCsv('data/sample_PT_100000x5.csv');
     await grok.data.detectSemanticTypes(df);
     await app.init(df, 'webLogoLargeApp');

package/src/tests/converters-test.ts

@@ -136,7 +136,7 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$$`,
     return function(srcCol: DG.Column): DG.Column {
       const converter = new NotationConverter(srcCol);
       const resCol = converter.convert(tgtNotation, tgtSeparator);
-      expect(resCol.getTag('units'), tgtNotation);
+      expect(resCol.getTag(DG.TAGS.UNITS), tgtNotation);
       return resCol;
     };
   }

package/src/tests/msa-tests.ts

@@ -7,7 +7,6 @@ import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-librarie
 import {runKalign} from '../utils/multiple-sequence-alignment';
 import {multipleSequenceAlignmentUI} from '../utils/multiple-sequence-alignment-ui';
 import {awaitContainerStart} from './utils';
-//import * as grok from 'datagrok-api/grok';
 
 category('MSA', async () => {
   //table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');
@@ -113,8 +112,8 @@ async function _testMsaIsCorrect(srcCsv: string, tgtCsv: string): Promise<void>
     srcCol.semType = semType;
 
   const tgtCol: DG.Column = tgtDf.getCol('seq')!;
-  const msaCol: DG.Column = await runKalign(srcCol, true);
-  expectArray(msaCol.toList(), tgtCol.toList());
+  const resCol: DG.Column = await runKalign(srcCol, true);
+  expectArray(resCol.toList(), tgtCol.toList());
 }
 
 async function _testMSAOnColumn(

package/src/tests/renderers-test.ts

@@ -1,6 +1,8 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
+import $ from 'cash-dom';
+
 import {category, expect, test, awaitCheck, delay} from '@datagrok-libraries/utils/src/test';
 
 import {importFasta} from '../package';
@@ -47,8 +49,12 @@ category('renderers', () => {
     await _selectRendererBySemType();
   });
 
-  test('setRendererManually', async () => {
-    await _setRendererManually();
+  test('setRendererManuallyBeforeAddColumn', async () => {
+    await _setRendererManuallyBeforeAddColumn();
+  }, {skipReason: 'GROK-11212'});
+
+  test('setRendererManuallyAfterAddColumn', async () => {
+    await _setRendererManuallyAfterAddColumn();
   }, {skipReason: 'GROK-11212'});
 
   async function _rendererMacromoleculeFasta() {
@@ -204,7 +210,7 @@ category('renderers', () => {
 
   /** GROK-11212 Do not overwrite / recalculate 'cell.renderer' tag that has been set programmatically
    * https://reddata.atlassian.net/browse/GROK-11212 */
-  async function _setRendererManually() {
+  async function _setRendererManuallyBeforeAddColumn() {
     const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
       ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
     seqDiffCol.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
@@ -227,4 +233,32 @@ category('renderers', () => {
         `instead of manual '${tgtCellRenderer}'.`);
     }
   }
+
+  /** GROK-11212 Do not overwrite / recalculate 'cell.renderer' tag that has been set programmatically
+   * https://reddata.atlassian.net/browse/GROK-11212 */
+  async function _setRendererManuallyAfterAddColumn() {
+    const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
+      ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
+    seqDiffCol.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
+    seqDiffCol.setTag(bioTAGS.separator, '/');
+    seqDiffCol.setTag(bioTAGS.aligned, 'SEQ');
+    seqDiffCol.setTag(bioTAGS.alphabet, 'UN');
+    seqDiffCol.setTag(bioTAGS.alphabetIsMultichar, 'true');
+    seqDiffCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    const tgtCellRenderer = 'MacromoleculeDifference';
+    const df = DG.DataFrame.fromColumns([seqDiffCol]);
+    await grok.data.detectSemanticTypes(df);
+    const tv = grok.shell.addTableView(df);
+    await awaitCheck(() => $(tv.root).find('.d4-grid canvas').length > 0, 'View grid canvas not found', 200);
+
+    seqDiffCol.setTag(DG.TAGS.CELL_RENDERER, tgtCellRenderer);
+    await awaitCheck(() => $(tv.root).find('.d4-grid canvas').length > 0, 'View grid canvas not found', 200);
+
+    const resCellRenderer = seqDiffCol.getTag(DG.TAGS.CELL_RENDERER);
+    if (resCellRenderer !== tgtCellRenderer) { // this is value of MacromoleculeDifferenceCR.cellType
+      throw new Error(`Tag 'cell.renderer' has been manually set to '${tgtCellRenderer}' for column ` +
+        `but after df was added as table, tag 'cell.renderer' has reset to '${resCellRenderer}' ` +
+        `instead of manual '${tgtCellRenderer}'.`);
+    }
+  }
 });

package/src/tests/splitters-test.ts

@@ -14,8 +14,16 @@ import {
 } from '@datagrok-libraries/utils/src/test';
 import * as C from '../utils/constants';
 import {_package, getHelmMonomers} from '../package';
-import {TAGS as bioTAGS, splitterAsFasta, splitterAsHelm} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {
+  TAGS as bioTAGS,
+  splitterAsFasta,
+  splitterAsHelm,
+  NOTATION
+} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {splitToMonomersUI} from '../utils/split-to-monomers';
+import {SEMTYPE} from 'datagrok-api/dg';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {TAGS} from '../utils/constants';
 
 
 category('splitters', async () => {
@@ -35,6 +43,12 @@ category('splitters', async () => {
       ['M', 'MeI', 'Y', 'K', 'E', 'T', 'L', 'L', 'MeF', 'P',
         'K', 'T', 'D', 'F', 'P', 'M', 'R', 'G', 'G', 'L', 'MeA'],
     ],
+    fastaFromHelm: [
+      '[meI][Pip][dK][Thr_PO3H2][L-hArg(Et,Et)][D-Tyr_Et][Tyr_ab-dehydroMe][dV]EN[D-Orn][D-aThr][Phe_4Me]',
+      ['meI', 'Pip', 'dK', 'Thr_PO3H2', 'L-hArg(Et,Et)', 'D-Tyr_Et', 'Tyr_ab-dehydroMe', 'dV', 'E', 'N', 'D-Orn',
+        'D-aThr', 'Phe_4Me'],
+    ],
+
     helm1: [
       'PEPTIDE1{meI.hHis.Aca.N.T.dE.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$',
       ['meI', 'hHis', 'Aca', 'N', 'T', 'dE', 'Thr_PO3H2', 'Aca', 'D-Tyr_Et',
@@ -68,6 +82,7 @@ category('splitters', async () => {
   };
 
   test('fastaMulti', async () => { await _testFastaSplitter(data.fastaMulti[0], data.fastaMulti[1]); });
+  test('fastaFromHelm', async () => { await _testFastaSplitter(data.fastaFromHelm[0], data.fastaFromHelm[1]); });
 
   test('helm1', async () => { await _testHelmSplitter(data.helm1[0], data.helm1[1]); });
   test('helm2', async () => { await _testHelmSplitter(data.helm2[0], data.helm2[1]); });
@@ -78,6 +93,7 @@ category('splitters', async () => {
   test('testHelm2', async () => { await _testHelmSplitter(data.testHelm2[0], data.testHelm2[1]); });
   test('testHelm3', async () => { await _testHelmSplitter(data.testHelm3[0], data.testHelm3[1]); });
 
+
   test('splitToMonomers', async () => {
     const df: DG.DataFrame = await grok.dapi.files.readCsv('System:AppData/Bio/samples/MSA.csv');
 
@@ -122,6 +138,16 @@ PEPTIDE1{hHis.Aca.Cys_SEt}$$$,5.72388
       throw new Error(msgs.join(' '));
     }
   });
+
+  // test('helmAsFasta', async () => {
+  //   // The columns can't be empty for UnitsHandler
+  //   /* eslint-disable max-len */
+  //   const srcSeq = '[meI][Pip][dK][Thr_PO3H2][L-hArg(Et,Et)][D-Tyr_Et][Tyr_ab-dehydroMe][dV]EN[D-Orn][D-aThr][Phe_4Me]';
+  //   const tgtSeqA = ['meI', 'Pip', 'dK', 'Thr_PO3H2', 'L-hArg(Et,Et)', 'D-Tyr_Et', 'Tyr_ab-dehydroMe', 'dV', 'E', 'N', 'D-Orn', 'D-aThr', 'Phe_4Me'];
+  //   /* eslint-enable max-len */
+  //   const resSeqA = splitterAsFasta(srcSeq);
+  //   expectArray(resSeqA, tgtSeqA);
+  // });
 });
 
 export async function _testFastaSplitter(src: string, tgt: string[]) {

package/src/tests/units-handler-splitted-tests.ts

@@ -2,11 +2,18 @@ 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 {category, test, expect, expectArray} from '@datagrok-libraries/utils/src/test';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {GapSymbols, UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 
 category('UnitsHandler', () => {
-  const data: { [testName: string]: { src: { csv: string }, tgt: { splitted: string[][] } } } = {
+  const fG = GapSymbols[NOTATION.FASTA];
+  const hG = GapSymbols[NOTATION.HELM];
+  const sG = GapSymbols[NOTATION.SEPARATOR];
+  const data: { [testName: string]: { src: { csv: string }, tgt: { splitted: (string[] | string)[] } } } = {
     fasta: {
       src: {
         csv: `seq
@@ -16,9 +23,9 @@ TTCAAC`
       },
       tgt: {
         splitted: [
-          ['A', 'C', 'G', 'T', 'C'],
-          ['C', 'A', 'G', 'T', 'G', 'T'],
-          ['T', 'T', 'C', 'A', 'A', 'C']
+          'ACGTC',
+          'CAGTGT',
+          'TTCAAC',
         ]
       }
     },
@@ -32,9 +39,9 @@ ACCGTACT`,
       tgt: {
         splitted: [
           //@formatter:off
-          ['A', 'C', '' , 'G', 'T', '' , 'C', 'T'],
-          ['C', 'A', 'C', '' , 'T', '' , 'G', 'T'],
-          ['A', 'C', 'C', 'G', 'T', 'A', 'C', 'T'],
+          'AC-GT-CT',
+          'CAC-T-GT',
+          'ACCGTACT',
           //@formatter:on
         ]
       }
@@ -65,8 +72,8 @@ rut12-rty-her2---wert`
       tgt: {
         splitted: [
           ['abc', 'dfgg', 'abc1', 'cfr3', 'rty', 'wert'],
-          ['rut12', 'her2', 'rty', '', 'abc1', 'dfgg'],
-          ['rut12', 'rty', 'her2', '', '', 'wert'],
+          ['rut12', 'her2', 'rty', sG, 'abc1', 'dfgg'],
+          ['rut12', 'rty', 'her2', sG, sG, 'wert'],
         ]
       }
     },
@@ -99,8 +106,8 @@ PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2}$$$$`
       expect(col.semType, DG.SEMTYPE.MACROMOLECULE);
 
       const uh = UnitsHandler.getOrCreate(col);
-      const splitted: string[][] = uh.splitted;
-      expectArray(splitted, testData.tgt.splitted);
+      const resSplitted: ISeqSplitted[] = uh.splitted;
+      expectArray(resSplitted, testData.tgt.splitted);
     });
   }
 });

package/src/tests/units-handler-tests.ts

@@ -41,25 +41,25 @@ category('UnitsHandler', () => {
   });
 
   test('Seq-Fasta-units', async () => {
-    const [_df, uh] = await loadCsvWithTag(seqDna, DG.TAGS.UNITS, NOTATION.FASTA);
+    const [_df, uh] = await loadCsvWithDetection(seqDna);
     expect(uh.notation, NOTATION.FASTA);
     expect(uh.isMsa(), false);
   });
 
   test('Seq-Fasta-MSA-units', async () => {
-    const [_df, uh] = await loadCsvWithTag(seqDnaMsa, DG.TAGS.UNITS, NOTATION.FASTA);
+    const [_df, uh] = await loadCsvWithDetection(seqDnaMsa);
     expect(uh.notation, NOTATION.FASTA);
     expect(uh.isMsa(), true);
   });
 
   test('Seq-Helm', async () => {
-    const [_df, uh] = await loadCsvWithTag(seqHelm, DG.TAGS.UNITS, NOTATION.HELM);
+    const [_df, uh] = await loadCsvWithDetection(seqHelm);
     expect(uh.notation, NOTATION.HELM);
     expect(uh.isHelm(), true);
   });
 
   test('Seq-UN', async () => {
-    const [_df, uh] = await loadCsvWithTag(seqUn, DG.TAGS.UNITS, NOTATION.SEPARATOR);
+    const [_df, uh] = await loadCsvWithDetection(seqUn);
     expect(uh.notation, NOTATION.SEPARATOR);
     expect(uh.separator, '-');
     expect(uh.alphabet, ALPHABET.UN);
@@ -79,15 +79,15 @@ category('UnitsHandler', () => {
     return [df, uh];
   }
 
-  async function loadCsvWithTag(csv: string, tag: string, value: string):
-    Promise<[df: DG.DataFrame, uh: UnitsHandler]> {
-    const df = DG.DataFrame.fromCsv(csv);
-    const col = df.getCol('seq');
-    col.setTag(tag, value);
-    col.semType = DG.SEMTYPE.MACROMOLECULE;
-    if (value === NOTATION.SEPARATOR)
-      col.setTag(TAGS.separator, '-');
-    const uh = UnitsHandler.getOrCreate(df.getCol('seq'));
-    return [df, uh];
-  }
+  // async function loadCsvWithTag(csv: string, tag: string, value: string):
+  //   Promise<[df: DG.DataFrame, uh: UnitsHandler]> {
+  //   const df = DG.DataFrame.fromCsv(csv);
+  //   const col = df.getCol('seq');
+  //   col.setTag(tag, value);
+  //   col.semType = DG.SEMTYPE.MACROMOLECULE;
+  //   if (value === NOTATION.SEPARATOR)
+  //     col.setTag(TAGS.separator, '-');
+  //   const uh = UnitsHandler.getOrCreate(df.getCol('seq'));
+  //   return [df, uh];
+  // }
 });

package/src/utils/cell-renderer.ts

@@ -2,13 +2,12 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
-import {_package, getBioLib} from '../package';
+import wu from 'wu';
+
 import {printLeftOrCentered, DrawStyle} from '@datagrok-libraries/bio/src/utils/cell-renderer';
-import * as C from './constants';
 import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
 import {
   getPaletteByType,
-  getSplitter,
   monomerToShort,
   MonomerToShortFunc,
   NOTATION,
@@ -18,8 +17,16 @@ import {
 import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import {UnknownSeqPalettes} from '@datagrok-libraries/bio/src/unknown';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
-import {Temps as mmcrTemps, Tags as mmcrTags,
-  tempTAGS, rendererSettingsChangedState} from '../utils/cell-renderer-consts';
+
+import {
+  Temps as mmcrTemps, Tags as mmcrTags,
+  tempTAGS, rendererSettingsChangedState
+} from '../utils/cell-renderer-consts';
+import * as C from './constants';
+
+import {_package, getBioLib} from '../package';
+import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+
 
 type TempType = { [tagName: string]: any };
 
@@ -30,20 +37,21 @@ function getUpdatedWidth(grid: DG.Grid | null, g: CanvasRenderingContext2D, x: n
   return grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
 }
 
-export function processSequence(subParts: string[]): [string[], boolean] {
-  const simplified = !subParts.some((amino, index) =>
+export function processSequence(subParts: ISeqSplitted): [string[], boolean] {
+  const simplified = !wu.enumerate(subParts).some(([amino, index]) =>
     amino.length > 1 &&
     index != 0 &&
     index != subParts.length - 1);
 
   const text: string[] = [];
   const gap = simplified ? '' : ' ';
-  subParts.forEach((amino: string, index) => {
+  for (const [amino, index] of wu.enumerate(subParts)) {
+    let aminoRes = amino;
     if (index < subParts.length)
-      amino += `${amino ? '' : '-'}${gap}`;
+      aminoRes += `${amino ? '' : '-'}${gap}`;
 
-    text.push(amino);
-  });
+    text.push(aminoRes);
+  }
   return [text, simplified];
 }
 
@@ -188,11 +196,12 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
 
       const separator = tableCol.getTag(bioTAGS.separator) ?? '';
       const splitLimit = w / 5;
-      const splitterFunc: SplitterFunc = getSplitter(units, separator, splitLimit);
+      const uh = UnitsHandler.getOrCreate(tableCol);
+      const splitterFunc: SplitterFunc = uh.getSplitter(splitLimit);
 
       const tempReferenceSequence: string | null = tableColTemp[tempTAGS.referenceSequence];
       const tempCurrentWord: string | null = tableColTemp[tempTAGS.currentWord];
-      const referenceSequence: string[] = splitterFunc(
+      const referenceSequence: ISeqSplitted = splitterFunc(
         ((tempReferenceSequence != null) && (tempReferenceSequence != '')) ?
           tempReferenceSequence : tempCurrentWord ?? '');
 
@@ -226,7 +235,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
       //   maxLengthWords = colTemp[tempTAGS.bioMaxLengthWords];
       // }
 
-      const subParts: string[] = splitterFunc(value);
+      const subParts: ISeqSplitted = splitterFunc(value);
       /* let x1 = x; */
       let color = undefinedColor;
       let drawStyle = DrawStyle.classic;
@@ -234,7 +243,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
       if (aligned && aligned.includes('MSA') && units == NOTATION.SEPARATOR)
         drawStyle = DrawStyle.MSA;
 
-      for (const [index, amino] of subParts.entries()) {
+      for (const [amino, index] of wu.enumerate(subParts)) {
         color = palette.get(amino);
         g.fillStyle = undefinedColor;
         const last = index === subParts.length - 1;
@@ -281,16 +290,16 @@ export class MacromoleculeDifferenceCellRenderer extends DG.GridCellRenderer {
     _cellStyle: DG.GridCellStyle): void {
     const grid = gridCell.grid;
     const cell = gridCell.cell;
+    const tableCol = gridCell.tableColumn as DG.Column<string>;
     const s: string = cell.value ?? '';
-    const separator = gridCell.tableColumn!.tags[bioTAGS.separator];
-    const units: string = gridCell.tableColumn!.tags[DG.TAGS.UNITS];
     w = getUpdatedWidth(grid, g, x, w);
     //TODO: can this be replaced/merged with splitSequence?
     const [s1, s2] = s.split('#');
-    const splitter = getSplitter(units, separator);
+    const uh = UnitsHandler.getOrCreate(tableCol);
+    const splitter = uh.getSplitter();
     const subParts1 = splitter(s1);
     const subParts2 = splitter(s2);
-    drawMoleculeDifferenceOnCanvas(g, x, y, w, h, subParts1, subParts2, units);
+    drawMoleculeDifferenceOnCanvas(g, x, y, w, h, subParts1, subParts2, uh.units);
   }
 }
 
@@ -300,14 +309,14 @@ export function drawMoleculeDifferenceOnCanvas(
   y: number,
   w: number,
   h: number,
-  subParts1: string [],
-  subParts2: string [],
+  subParts1: ISeqSplitted,
+  subParts2: ISeqSplitted,
   units: string,
   fullStringLength?: boolean,
   molDifferences?: { [key: number]: HTMLCanvasElement },
 ): void {
   if (subParts1.length !== subParts2.length) {
-    const sequences: IComparedSequences = fillShorterSequence(subParts1, subParts2);
+    const sequences: IComparedSequences = fillShorterSequence(wu(subParts1).toArray(), wu(subParts2).toArray());
     subParts1 = sequences.subParts1;
     subParts2 = sequences.subParts2;
   }