@datagrok/bio 2.4.48 → 2.4.50

package/files/samples/sample_HELM.csv

@@ -538,4 +538,4 @@ PEPTIDE1{aThr.hHis.Aca.Q.T.W.Q.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.Q.N.N.Phe_4Me}$$
 PEPTIDE1{meI.hHis.Aca.Q.T.W.Q.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.Bmt.Phe_4Me}$$$$,1.3272504220357146
 PEPTIDE1{meI.hHis.Aca.Q.T.W.Q.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.Thr_PO3H2.Phe_4Me}$$$$,2.25061208046269
 PEPTIDE1{meI.hHis.Aca.Q.T.W.Q.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.dV.Phe_4Me}$$$$,4.2426827257450315
-PEPTIDE1{meI.hHis.Hcy.Q.T.W.Q.Phe_4NH2.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.N.meK}$$$$,2.9379590568765788
+PEPTIDE1{meI.hHis.Hcy.Q.T.W.Q.Phe_4NH2.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.N.meK}$$$$,2.9379590568765788

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.4.48",
+  "version": "2.4.50",
   "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",
@@ -22,7 +22,7 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.32.5",
+    "@datagrok-libraries/bio": "^5.32.7",
     "@datagrok-libraries/chem-meta": "^1.0.1",
     "@datagrok-libraries/ml": "^6.3.39",
     "@datagrok-libraries/tutorials": "^1.3.2",
@@ -34,7 +34,6 @@
     "fastest-levenshtein": "^1.0.16",
     "openchemlib": "6.0.1",
     "rxjs": "^6.5.5",
-    "source-map-loader": "^4.0.1",
     "style-loader": "^3.3.1",
     "wu": "latest"
   },
@@ -45,6 +44,7 @@
     "@typescript-eslint/parser": "latest",
     "eslint": "latest",
     "eslint-config-google": "latest",
+    "source-map-loader": "^4.0.1",
     "ts-loader": "^9.2.5",
     "typescript": "^5.0.4",
     "webpack": "^5.76.0",

package/src/calculations/monomerLevelMols.ts

@@ -13,7 +13,7 @@ export async function getMonomericMols(
   const uh = UnitsHandler.getOrCreate(mcol);
   let molV3000Array;
   monomersDict ??= new Map();
-  const monomers = uh.units === NOTATION.HELM ?
+  const monomers = uh.isHelm() ?
     getHelmMonomers(mcol) : Object.keys(uh.stats.freq).filter((it) => it !== '');
 
   for (let i = 0; i < monomers.length; i++) {
@@ -21,7 +21,7 @@ export async function getMonomericMols(
       monomersDict.set(monomers[i], `${monomersDict.size + 1}`);
   }
 
-  if (uh.units === NOTATION.HELM) {
+  if (uh.isHelm()) {
     molV3000Array = await grok.functions.call('HELM:getMolFiles', {col: mcol});
     molV3000Array = changeV2000ToV3000(molV3000Array, monomersDict, pattern);
   } else {

package/src/package-test.ts

@@ -13,6 +13,7 @@ import './tests/splitters-test'; //Unhandled exceptions.exceptions : Cannot read
 
 import './tests/monomer-libraries-tests';
 import './tests/renderers-test';
+import './tests/renderers-monomer-placer';
 import './tests/converters-test';
 import './tests/fasta-handler-test';
 import './tests/fasta-export-tests';

package/src/tests/renderers-monomer-placer.ts

@@ -0,0 +1,109 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+
+import {_package} from '../package-test';
+import {after, before, category, delay, expect, test} from '@datagrok-libraries/utils/src/test';
+import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
+import {monomerToShort} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+
+category('renderers: monomerPlacer', () => {
+  const tests = {
+    splitter: {
+      /**
+       0 = Array(10) [0, 26, 45, 71, 97, 123, 142, 161, 187, 213],
+       1 = Array(9) [0, 26, 52, 78, 104, 130, 156, 182, 208],
+       2 = Array(8) [0, 26, 45, 71, 97, 123, 149, 175],
+       * */
+      csv: 'id,seq\n' +
+        'id1,m1-M-m3-mon4-mon5-N-T-MON8-N9\n' + //Array(10) [0, 26, 52, 78, 104, 130, 156, 175, 201, 227]
+        'id2,m1-mon2-m3-mon4-mon5-Num-MON8-N9\n' + //
+        'id3,mon1-M-mon3-mon4-mon5-MON8-N9\n', //
+      testList: [
+        {src: {row: 0, x: -1}, tgt: {pos: null}},
+        {src: {row: 1, x: 0}, tgt: {pos: 0}},
+        {src: {row: 1, x: 1}, tgt: {pos: 0}},
+        {src: {row: 1, x: 26}, tgt: {pos: 1}},
+        {src: {row: 1, x: 170}, tgt: {pos: 6}},
+        {src: {row: 1, x: 208}, tgt: {pos: null}},
+        {src: {row: 2, x: 170}, tgt: {pos: 6}},
+        {src: {row: 2, x: 175}, tgt: {pos: null}},
+      ]
+    },
+    splitterMsa: {
+      /** For charWidth=7 and sepWidth=12, MSA
+       * Array(10) [0, 26, 52, 78, 104, 130, 156, 175, 201, 227]
+       */
+      csv: 'id,seq\n' +
+        'id1,m1-M-m3-mon4-mon5-N-T-MON8-N9\n' + //Array(10) [0, 26, 52, 78, 104, 130, 156, 175, 201, 227]
+        'id2,m1-mon2-m3-mon4-mon5-Num--MON8-N9\n' + //
+        'id3,mon1-M-mon3-mon4-mon5---MON8-N9\n', //
+      testList: [
+        {src: {row: 0, x: -1}, tgt: {pos: null}},
+        {src: {row: 1, x: 0}, tgt: {pos: 0}},
+        {src: {row: 1, x: 1}, tgt: {pos: 0}},
+        {src: {row: 1, x: 26}, tgt: {pos: 1}},
+        {src: {row: 1, x: 170}, tgt: {pos: 6}},
+        {src: {row: 1, x: 227}, tgt: {pos: null}},
+        {src: {row: 2, x: 220}, tgt: {pos: 8}},
+        {src: {row: 2, x: 227}, tgt: {pos: null}},
+      ]
+    },
+    fastaMsa: {
+      /** For charWidth=7 and sepWidth=12, MSA
+       * Array(10) [0, 19, 38, 57, 76, 95, 114, 133, 152, 171]
+       */
+      csv: `id,seq
+id1,QQYNIYPLT
+id2,QQWSSFPYT
+id3,QHIRE--LT
+`,
+      testList: [
+        {src: {row: 1, x: -1}, tgt: {pos: null}},
+        {src: {row: 1, x: 0}, tgt: {pos: 0}},
+        {src: {row: 1, x: 1}, tgt: {pos: 0}},
+        {src: {row: 1, x: 19}, tgt: {pos: 1}},
+        {src: {row: 1, x: 170}, tgt: {pos: 8}},
+        {src: {row: 1, x: 171}, tgt: {pos: null}},
+        {src: {row: 2, x: 170}, tgt: {pos: 8}},
+        {src: {row: 2, x: 171}, tgt: {pos: null}},
+      ]
+    },
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`getPosition_${testName}`, async () => {
+      const df: DG.DataFrame = DG.DataFrame.fromCsv(testData.csv);
+      await grok.data.detectSemanticTypes(df);
+      const seqCol: DG.Column = df.getCol('seq');
+
+      const monLength: number = 1;
+      const charWidth: number = 7;
+      const sepWidth: number = 12;
+      const colTemp: MonomerPlacer = new MonomerPlacer(null, seqCol, () => {
+        const uh = UnitsHandler.getOrCreate(seqCol);
+        return {
+          unitsHandler: uh,
+          monomerCharWidth: charWidth,
+          separatorWidth: sepWidth,
+          monomerToShort: monomerToShort,
+          monomerLengthLimit: monLength,
+        };
+      });
+
+      const testList = testData.testList;
+
+      const errorList: string[] = [];
+      for (const test of testList) {
+        const res = {pos: colTemp.getPosition(test.src.row, test.src.x)};
+        if (test.tgt.pos != res.pos) {
+          errorList.push(`Test src ${JSON.stringify(test.src)} expected tgt ${JSON.stringify(test.tgt)},` +
+            ` but get ${JSON.stringify({res})}`);
+        }
+      }
+      if (errorList.length > 0)
+        throw new Error('Test failed error(s):\n' + errorList.join(', n'));
+    });
+  }
+});

package/src/tests/renderers-test.ts

@@ -108,8 +108,11 @@ category('renderers', () => {
   async function _rendererMacromoleculeDifference() {
     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.tags[DG.TAGS.UNITS] = NOTATION.SEPARATOR;
-    seqDiffCol.tags[bioTAGS.separator] = '/';
+    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 = C.SEM_TYPES.MACROMOLECULE_DIFFERENCE;
     const df = DG.DataFrame.fromColumns([seqDiffCol]);
 
@@ -195,8 +198,11 @@ category('renderers', () => {
     /**/
     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.tags[DG.TAGS.UNITS] = NOTATION.SEPARATOR;
-    seqDiffCol.tags[bioTAGS.separator] = '/';
+    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 = C.SEM_TYPES.MACROMOLECULE_DIFFERENCE;
     const df = DG.DataFrame.fromColumns([seqDiffCol]);
     const tv = grok.shell.addTableView(df);
@@ -217,8 +223,11 @@ category('renderers', () => {
   async function _setRendererManually() {
     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.tags[DG.TAGS.UNITS] = NOTATION.SEPARATOR;
-    seqDiffCol.tags[bioTAGS.separator] = '/';
+    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';
     seqDiffCol.setTag(DG.TAGS.CELL_RENDERER, tgtCellRenderer);

package/src/tests/utils/sequences-generators.ts

@@ -23,21 +23,12 @@ export function generateLongSequence(): DG.Column[] {
   return columns;
 }
 
-export function setTagsMacromolecule(col: DG.Column) {
-  col.semType = DG.SEMTYPE.MACROMOLECULE;
-  col.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
-  col.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
-  col.setTag(bioTAGS.alphabet, ALPHABET.UN);
-  col.setTag(bioTAGS.separator, '/');
-  return col;
-}
-
 export function performanceTest(generateFunc: () => DG.Column[], testName: string) {
   const columns = generateFunc();
   const df: DG.DataFrame = DG.DataFrame.fromColumns(columns);
+  grok.data.detectSemanticTypes(df);
   const startTime: number = Date.now();
   const col: DG.Column = df.columns.byName('MSA');
-  setTagsMacromolecule(col);
   grok.shell.addTableView(df);
 
   const endTime: number = Date.now();

package/src/utils/cell-renderer.ts

@@ -2,37 +2,45 @@ 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 {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 {
   ALIGNMENT, ALPHABET,
   getPaletteByType,
   getSplitter,
+  getSplitterForColumn,
   monomerToShort,
+  MonomerToShortFunc,
   NOTATION,
   SplitterFunc,
   TAGS as bioTAGS,
 } from '@datagrok-libraries/bio/src/utils/macromolecule';
 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 {MonomerWorks} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
 import {Tags as mmcrTags, Temps as mmcrTemps} from '../utils/cell-renderer-consts';
-
-import * as C from './constants';
-import {_package} from '../package';
+import { HELM_POLYMER_TYPE } from '@datagrok-libraries/bio/src/utils/const';
+import { MonomerLib } from './monomer-lib';
+import { IMonomerLib } from '@datagrok-libraries/bio/src/types';
 
 const enum tempTAGS {
   referenceSequence = 'reference-sequence',
   currentWord = 'current-word',
   monomerWidth = 'monomer-width',
-  bioSumMaxLengthWords = 'bio-sum-maxLengthWords',
-  bioMaxIndex = 'bio-maxIndex',
-  bioMaxLengthWords = 'bio-maxLengthWords',
+  bioSeqCol = 'bio-seqCol',
+}
+
+const enum rndrTAGS {
+  calculatedCellRender = '.calculatedCellRender',
 }
 
 type TempType = { [tagName: string]: any };
 
 const undefinedColor = 'rgb(100,100,100)';
-const monomerToShortFunction: (amino: string, maxLengthOfMonomer: number) => string = monomerToShort;
+const monomerToShortFunction: MonomerToShortFunc = monomerToShort;
 
 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;
@@ -55,8 +63,9 @@ export function processSequence(subParts: string[]): [string[], boolean] {
   return [text, simplified];
 }
 
-
 export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
+  private padding: number = 5;
+
   get name(): string { return 'sequence'; }
 
   get cellType(): string { return 'sequence'; }
@@ -72,39 +81,39 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
   }
 
   onMouseMove(gridCell: DG.GridCell, e: MouseEvent): void {
-    if (gridCell.cell.column.getTag(bioTAGS.aligned) !== ALIGNMENT.SEQ_MSA)
-      return;
-
-    const colTemp: TempType = gridCell.cell.column.temp;
-    const maxLengthWordsSum = colTemp[tempTAGS.bioSumMaxLengthWords];
-    const maxIndex = colTemp[tempTAGS.bioMaxIndex];
-    const argsX = e.offsetX - gridCell.gridColumn.left + (gridCell.gridColumn.left - gridCell.bounds.x);
-    let left = 0;
-    let right = maxIndex;
-    let found = false;
-    maxLengthWordsSum[maxIndex + 1] = argsX + 1;
-    let mid = 0;
-    if (argsX > maxLengthWordsSum[0]) {
-      while (!found) {
-        mid = Math.floor((right + left) / 2);
-        if (argsX >= maxLengthWordsSum[mid] && argsX <= maxLengthWordsSum[mid + 1]) {
-          left = mid;
-          found = true;
-        } else if (argsX < maxLengthWordsSum[mid]) {
-          right = mid - 1;
-        } else if (argsX > maxLengthWordsSum[mid + 1]) {
-          left = mid + 1;
-        }
-        if (left == right)
-          found = true;
+    // if (gridCell.cell.column.getTag(bioTAGS.aligned) !== ALIGNMENT.SEQ_MSA)
+    //   return;
+
+    const tableCol: DG.Column = gridCell.cell.column;
+    const tableColTemp: TempType = tableCol.temp;
+    const seqColTemp: MonomerPlacer = tableCol.temp[tempTAGS.bioSeqCol];
+    if (!seqColTemp) return; // Can do nothing without precalculated data
+
+    const gridCellBounds: DG.Rect = gridCell.bounds;
+    // const value: any = gridCell.cell.value;
+    //
+    // const maxLengthWords: number[] = seqColTemp.getCellMonomerLengths(gridCell.tableRowIndex!);
+    // const maxLengthWordsSum: number[] = new Array<number>(maxLengthWords.length).fill(0);
+    // for (let posI: number = 1; posI < maxLengthWords.length; posI++)
+    //   maxLengthWordsSum[posI] = maxLengthWordsSum[posI - 1] + maxLengthWords[posI];
+    // const maxIndex = maxLengthWords.length;
+    const argsX = e.offsetX - gridCell.gridColumn.left + (gridCell.gridColumn.left - gridCellBounds.x);
+    const left: number | null = seqColTemp.getPosition(gridCell.tableRowIndex!, argsX);
+
+    const seqMonList: string[] = seqColTemp.getSeqMonList(gridCell.tableRowIndex!);
+    if (left !== null && left < seqMonList.length) {
+      const monomerSymbol: string = seqMonList[left];
+      const tooltipElements: HTMLElement[] = [ui.div(monomerSymbol)];
+      const monomer = seqColTemp.getMonomer(monomerSymbol);
+      if(monomer) {
+      const options = {autoCrop: true, autoCropMargin: 0, suppressChiralText: true};
+      const monomerSVG = grok.chem.svgMol(monomer.smiles, undefined, undefined, options);
+      tooltipElements.push(monomerSVG);
       }
+      ui.tooltip.show(ui.divV(tooltipElements), e.x + 16, e.y + 16);
+    } else {
+      ui.tooltip.hide();
     }
-    left = (argsX >= maxLengthWordsSum[left]) ? left + 1 : left;
-    const separator = gridCell.cell.column.getTag('separator') ?? '';
-    const splitterFunc: SplitterFunc = getSplitter('separator', separator);
-    const subParts: string[] = splitterFunc(gridCell.cell.value);
-    (((subParts[left]?.length ?? 0) > 0)) ?
-      ui.tooltip.show(ui.div(subParts[left]), e.x + 16, e.y + 16) : ui.tooltip.hide();
   }
 
   /**
@@ -120,102 +129,130 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
    * @memberof AlignedSequenceCellRenderer
    */
   render(
-    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number,
-    gridCell: DG.GridCell, _cellStyle: DG.GridCellStyle,
-  ) {
-    const grid = gridCell.gridRow !== -1 ? gridCell.grid : null;
-    const cell = gridCell.cell;
-    const paletteType = gridCell.cell.column.getTag(bioTAGS.alphabet);
-    const minDistanceRenderer = 50;
-    w = getUpdatedWidth(grid, g, x, w);
-    g.save();
-    g.beginPath();
-    g.rect(x, y, w, h);
-    g.clip();
-    g.font = '12px monospace';
-    g.textBaseline = 'top';
-
-    //TODO: can this be replaced/merged with splitSequence?
-    const units = gridCell.cell.column.getTag(DG.TAGS.UNITS);
-    const aligned: string = gridCell.cell.column.getTag(bioTAGS.aligned);
-
-    const palette = getPaletteByType(paletteType);
-
-    const separator = gridCell.cell.column.getTag(bioTAGS.separator) ?? '';
-    const splitLimit = w / 5;
-    const splitterFunc: SplitterFunc = getSplitter(units, separator, splitLimit);
+    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
+    cellStyle: DG.GridCellStyle
+  ): void {
+    let gapRenderer = 5;
+    let maxLengthOfMonomer = 8;
 
     // TODO: Store temp data to GridColumn
     // Now the renderer requires data frame table Column underlying GridColumn
-    const colTemp: TempType = gridCell.cell.column.temp;
-
-    const tempReferenceSequence: string | null = colTemp[tempTAGS.referenceSequence];
-    const tempCurrentWord: string | null = colTemp[tempTAGS.currentWord];
-    const tempMonomerWidth: string | null = colTemp[tempTAGS.monomerWidth];
-    const referenceSequence: string[] = splitterFunc(
-      ((tempReferenceSequence != null) && (tempReferenceSequence != '')) ?
-        tempReferenceSequence : tempCurrentWord ?? '');
-    const monomerWidth: string = tempMonomerWidth ?? 'short';
-
-    let gapRenderer = 5;
-    let maxIndex = 0;
-    let maxLengthOfMonomer: number = 8;
+    const view = gridCell.grid.view;
+    const tableCol: DG.Column = gridCell.cell.column;
+    const tableColTemp: TempType = tableCol.temp;
 
+    // Cell renderer settings
+    const tempMonomerWidth: string | null = tableColTemp[tempTAGS.monomerWidth];
+    const monomerWidth: string = (tempMonomerWidth != null) ? tempMonomerWidth : 'short';
     if (monomerWidth === 'short') {
-      gapRenderer = 12;
-      maxLengthOfMonomer = colTemp[mmcrTemps.maxMonomerLength] ?? _package.properties.maxMonomerLength;
+      maxLengthOfMonomer = tableColTemp[mmcrTemps.maxMonomerLength] ?? _package.properties.maxMonomerLength;
     }
 
-    let maxLengthWords: any = {};
-    if (gridCell.cell.column.getTag(mmcrTags.calculated) !== splitLimit.toString()) {
-      let samples = 0;
-      while (samples < Math.min(gridCell.cell.column.length, 100)) {
-        const column = gridCell.cell.column.get(samples);
-        const subParts: string[] = splitterFunc(column);
-        subParts.forEach((amino, index) => {
-          const textSize = monomerToShortFunction(amino, maxLengthOfMonomer).length * 7 + gapRenderer;
-          if (textSize > (maxLengthWords[index] ?? 0))
-            maxLengthWords[index] = textSize;
-          if (index > maxIndex) maxIndex = index;
+    let seqColTemp: MonomerPlacer = tableCol.temp[tempTAGS.bioSeqCol];
+    if (!seqColTemp) {
+      seqColTemp = new MonomerPlacer(view, tableCol,
+        () => {
+          const uh = UnitsHandler.getOrCreate(tableCol);
+          return {
+            unitsHandler: uh,
+            monomerCharWidth: 7, separatorWidth: !uh.isMsa() ? gapRenderer : 8,
+            monomerToShort: monomerToShortFunction, monomerLengthLimit: maxLengthOfMonomer,
+            monomerLib: getBioLib()
+          };
         });
-        samples += 1;
-      }
-      const minLength = 3 * 7;
-      for (let i = 0; i <= maxIndex; i++) {
-        if (maxLengthWords[i] < minLength) maxLengthWords[i] = minLength;
-        const maxLengthWordSum: any = {};
-        maxLengthWordSum[0] = maxLengthWords[0];
-        for (let i = 1; i <= maxIndex; i++) maxLengthWordSum[i] = maxLengthWordSum[i - 1] + maxLengthWords[i];
-        colTemp[tempTAGS.bioSumMaxLengthWords] = maxLengthWordSum;
-        colTemp[tempTAGS.bioMaxIndex] = maxIndex;
-        colTemp[tempTAGS.bioMaxLengthWords] = maxLengthWords;
-        gridCell.cell.column.setTag(mmcrTags.calculated, splitLimit.toString());
-      }
-    } else {
-      maxLengthWords = colTemp[tempTAGS.bioMaxLengthWords];
     }
 
-    const subParts: string[] = splitterFunc(cell.value);
-    let x1 = x;
-    let color = undefinedColor;
-    let drawStyle = DrawStyle.classic;
-
-
-    if (aligned && aligned.includes('MSA') && units == NOTATION.SEPARATOR)
-      drawStyle = DrawStyle.MSA;
+    const [maxLengthWords, maxLengthWordsSum]: [number[], number[]] =
+      seqColTemp.getCellMonomerLengths(gridCell.tableRowIndex!);
+    const maxIndex = maxLengthWords.length;
 
-    subParts.every((amino, index) => {
-      color = palette.get(amino);
-      g.fillStyle = undefinedColor;
-      const last = index === subParts.length - 1;
-      x1 = printLeftOrCentered(x1, y, w, h,
-        g, amino, color, 0, true, 1.0, separator, last, drawStyle,
-        maxLengthWords, index, gridCell, referenceSequence, maxLengthOfMonomer);
-      return minDistanceRenderer <= w;
-    });
+    // Store updated seqColTemp to the col temp
+    if (seqColTemp.updated) tableColTemp[tempTAGS.bioSeqCol] = seqColTemp;
 
-    g.restore();
-    return;
+    g.save();
+    try {
+      const grid = gridCell.gridRow !== -1 ? gridCell.grid : null;
+      const value: any = gridCell.cell.value;
+      const paletteType = tableCol.getTag(bioTAGS.alphabet);
+      const minDistanceRenderer = 50;
+      w = getUpdatedWidth(grid, g, x, w);
+      g.beginPath();
+      g.rect(x + this.padding, y + this.padding, w - this.padding - 1, h - this.padding * 2);
+      g.clip();
+      g.font = '12px monospace';
+      g.textBaseline = 'top';
+
+      //TODO: can this be replaced/merged with splitSequence?
+      const units = tableCol.getTag(DG.TAGS.UNITS);
+      const aligned: string = tableCol.getTag(bioTAGS.aligned);
+
+      const palette = getPaletteByType(paletteType);
+
+      const separator = tableCol.getTag(bioTAGS.separator) ?? '';
+      const splitLimit = w / 5;
+      const splitterFunc: SplitterFunc = getSplitter(units, separator, splitLimit);
+
+      const tempReferenceSequence: string | null = tableColTemp[tempTAGS.referenceSequence];
+      const tempCurrentWord: string | null = tableColTemp[tempTAGS.currentWord];
+      const referenceSequence: string[] = splitterFunc(
+        ((tempReferenceSequence != null) && (tempReferenceSequence != '')) ?
+          tempReferenceSequence : tempCurrentWord ?? '');
+
+      // let maxLengthWords: { [pos: number]: number } = {};
+      // if (tableCol.getTag(rndrTAGS.calculatedCellRender) !== splitLimit.toString()) {
+      //   let sampleCount = 0;
+      //   while (sampleCount < Math.min(tableCol.length, 100)) {
+      //     const rowIdx: number = sampleCount;
+      //     const column = tableCol.get(rowIdx);
+      //     const subParts: string[] = splitterFunc(column);
+      //     for (const [index, amino] of subParts.entries()) {
+      //       const textSize = monomerToShortFunction(amino, maxLengthOfMonomer).length * 7 + gapRenderer;
+      //       if (textSize > (maxLengthWords[index] ?? 0))
+      //         maxLengthWords[index] = textSize;
+      //       if (index > maxIndex) maxIndex = index;
+      //     }
+      //     sampleCount += 1;
+      //   }
+      //   const minLength = 3 * 7;
+      //   for (let i = 0; i <= maxIndex; i++) {
+      //     if (maxLengthWords[i] < minLength) maxLengthWords[i] = minLength;
+      //     const maxLengthWordSum: { [pos: number]: number } = {};
+      //     maxLengthWordSum[0] = maxLengthWords[0];
+      //     for (let i = 1; i <= maxIndex; i++) maxLengthWordSum[i] = maxLengthWordSum[i - 1] + maxLengthWords[i];
+      //     colTemp[tempTAGS.bioSumMaxLengthWords] = maxLengthWordSum;
+      //     colTemp[tempTAGS.bioMaxIndex] = maxIndex;
+      //     colTemp[tempTAGS.bioMaxLengthWords] = maxLengthWords;
+      //     tableCol.setTag(rndrTAGS.calculatedCellRender, splitLimit.toString());
+      //   }
+      // } else {
+      //   maxLengthWords = colTemp[tempTAGS.bioMaxLengthWords];
+      // }
+
+      const subParts: string[] = splitterFunc(value);
+      /* let x1 = x; */
+      let color = undefinedColor;
+      let drawStyle = DrawStyle.classic;
+
+      if (aligned && aligned.includes('MSA') && units == NOTATION.SEPARATOR)
+        drawStyle = DrawStyle.MSA;
+
+      for (const [index, amino] of subParts.entries()) {
+        color = palette.get(amino);
+        g.fillStyle = undefinedColor;
+        const last = index === subParts.length - 1;
+        /*x1 = */
+        printLeftOrCentered(x + this.padding, y, w, h,
+          g, amino, color, 0, true, 1.0, separator, last, drawStyle,
+          maxLengthWordsSum, index, gridCell, referenceSequence, maxLengthOfMonomer);
+        if (minDistanceRenderer > w) break;
+      }
+    } catch (err: any) {
+      const errMsg: string = err instanceof Error ? err.message : !!err ? err.toString() : 'Error \'undefined\'';
+      _package.logger.error(`Bio: MacromoleculeSequenceCellRenderer.render() error: ${errMsg}`);
+      //throw err; // Do not throw to prevent disabling renderer
+    } finally {
+      g.restore();
+    }
   }
 }
 

package/src/utils/convert.ts

@@ -4,8 +4,10 @@ import * as grok from 'datagrok-api/grok';
 
 import $ from 'cash-dom';
 import {Subscription} from 'rxjs';
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {expect} from '@datagrok-libraries/utils/src/test';
 
 
 let convertDialog: DG.Dialog | null = null;
@@ -127,6 +129,8 @@ export async function convertDo(
     newColumn.semType = semType;
 
   // call to calculate 'cell.renderer' tag
+  const newUH = UnitsHandler.getOrCreate(newColumn);
+  expect(newUH.isMsa(), true);
   await grok.data.detectSemanticTypes(srcCol.dataFrame);
 
   return newColumn;