@datagrok/bio 2.4.31 → 2.4.39

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

@@ -6,14 +6,18 @@ import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-librarie
 
 export function generateManySequences(): DG.Column[] {
   const columns: DG.Column[] = [];
-  columns.push(DG.Column.fromList('string', 'MSA', new Array(10 ** 6).fill('meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me')));
+  columns.push(DG.Column.fromList('string', 'MSA',
+    new Array(10 ** 6).fill(
+      'meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me')),
+  );
   columns.push(DG.Column.fromList('string', 'Activity', new Array(10 ** 6).fill('5.30751')));
   return columns;
 }
 
 export function generateLongSequence(): DG.Column[] {
   const columns: DG.Column[] = [];
-  const longSequence = `meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr`.repeat(10 ** 5);
+  const longSequence =
+    `meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr`.repeat(10 ** 5);
   columns.push(DG.Column.fromList('string', 'MSA', new Array(10 ** 2).fill(longSequence)));
   columns.push(DG.Column.fromList('string', 'Activity', new Array(10 ** 2).fill('7.30751')));
   return columns;

package/src/tests/utils.ts

@@ -2,8 +2,7 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
 import {_package} from '../package-test';
-import {expect} from '@datagrok-libraries/utils/src/test';
-import {runKalign} from '../utils/multiple-sequence-alignment';
+import {delay, expect} from '@datagrok-libraries/utils/src/test';
 
 export async function loadFileAsText(name: string): Promise<string> {
   return await _package.files.readAsText(name);
@@ -27,8 +26,15 @@ export async function createTableView(tableName: string): Promise<DG.TableView>
 /**
  * Tests if a table has non zero rows and columns.
  *
- * @param {DG.DataFrame} table Target table.
- */
+ * @param {DG.DataFrame} table Target table. */
 export function _testTableIsNotEmpty(table: DG.DataFrame): void {
   expect(table.columns.length > 0 && table.rowCount > 0, true);
 }
+
+/** Waits if container is not started
+ * @param {number} ms - time to wait in milliseconds */
+export async function awaitContainerStart(ms: number = 10000): Promise<void> {
+  const pepseaContainer = await grok.dapi.docker.dockerContainers.filter('bio').first();
+  if (pepseaContainer.status !== 'started' && pepseaContainer.status !== 'checking')
+    await delay(ms);
+}

package/src/tests/viewers.ts

@@ -2,7 +2,7 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 //import * as ui from 'datagrok-api/ui';
 
-import {category, delay, test, testViewer} from '@datagrok-libraries/utils/src/test';
+import {category, delay, test} from '@datagrok-libraries/utils/src/test';
 import {readDataframe} from './utils';
 
 

package/src/utils/atomic-works.ts

@@ -1,13 +1,10 @@
-import * as OCL from 'openchemlib/full.js';
 import * as grok from 'datagrok-api/grok';
 
-import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
-
 export async function getMacroMol(monomers: any[][]): Promise<string[]> {
-  let result: string[] = [];
+  const result: string[] = [];
   const moduleRdkit = await grok.functions.call('Chem:getRdKitModule');
-  for(let i = 0; i < monomers.length; i++) {
-    for (let j = 0; j < monomers[i].length; j++){
+  for (let i = 0; i < monomers.length; i++) {
+    for (let j = 0; j < monomers[i].length; j++) {
       const mol = moduleRdkit.get_mol(monomers[i][j]['molfile']);
       const a = mol.get_v3Kmolblock();
       const indices = getIndices(monomers[i][j], a);
@@ -22,17 +19,17 @@ export async function getMacroMol(monomers: any[][]): Promise<string[]> {
   return result;
 }
 
-function getIndices(monomer: any, molV3000: string): {first: number, last: number, 
-                                    remFirst: number, remLast: number, 
+function getIndices(monomer: any, molV3000: string): {first: number, last: number,
+                                    remFirst: number, remLast: number,
                                     remBondFirst: number, remBondLast: Number} {
-  const molfile = monomer["molfile"];
+  const molfile = monomer['molfile'];
   let indexStart = molfile.indexOf('M  RGP', 0) + 8;
   let indexEnd = molfile.indexOf('\n', indexStart);
   const indicesData = molfile.substring(indexStart, indexEnd).replaceAll('  ', ' ').replaceAll('  ', ' ');
-  let parsedData = indicesData.split(' ')
+  let parsedData = indicesData.split(' ');
   const remFirst = parsedData[2] == '1' ? parseInt(parsedData[1]) : parseInt(parsedData[3]);
   const remLast = parsedData[2] == '2' ? parseInt(parsedData[1]) : parseInt(parsedData[3]);
-  
+
   const numbers = extractAtomsBondsNumbersV3000(molV3000);
   let indexBonds = molV3000.indexOf('M  V30 BEGIN BOND'); // V3000 index for bonds
   indexBonds = molV3000.indexOf('\n', indexBonds);
@@ -45,25 +42,22 @@ function getIndices(monomer: any, molV3000: string): {first: number, last: numbe
   let remBondLast = 0;
 
   for (let j = 0; j < numbers.nbond; j++) {
-    if(first == 0 || last == 0){
+    if (first == 0 || last == 0) {
       indexStart = molV3000.indexOf('V30', indexStart) + 4;
       indexEnd = molV3000.indexOf('\n', indexStart);
       const bondData = molV3000.substring(indexStart, indexEnd).replaceAll('  ', ' ').replaceAll('  ', ' ');
-      parsedData = bondData.split(' ')
+      parsedData = bondData.split(' ');
 
-      if(parseInt(parsedData[2]) == remFirst){
+      if (parseInt(parsedData[2]) == remFirst) {
         first = parseInt(parsedData[3]);
         remBondFirst = parseInt(parsedData[0]);
-      }
-      else if(parseInt(parsedData[3]) == remFirst){
+      } else if (parseInt(parsedData[3]) == remFirst) {
         first = parseInt(parsedData[2]);
         remBondFirst = parseInt(parsedData[0]);
-      }
-      else if(parseInt(parsedData[2]) == remLast){
+      } else if (parseInt(parsedData[2]) == remLast) {
         last = parseInt(parsedData[3]);
         remBondLast = parseInt(parsedData[0]);
-      }
-      else if(parseInt(parsedData[3]) == remLast){
+      } else if (parseInt(parsedData[3]) == remLast) {
         last = parseInt(parsedData[2]);
         remBondLast = parseInt(parsedData[0]);
       }
@@ -79,8 +73,8 @@ async function rotateBackboneV3000(molBlock: string, indices:any): Promise<strin
   const first = indices['first'];
   const last = indices['last'];
 
-  const xCenter = (coordinates.x[last] + coordinates.x[first])/2;
-  const yCenter = (coordinates.y[last] + coordinates.y[first])/2;
+  const xCenter = (coordinates.x[last] + coordinates.x[first]) / 2;
+  const yCenter = (coordinates.y[last] + coordinates.y[first]) / 2;
 
   //place to center
   for (let i = 0; i < natom; i++) {
@@ -89,13 +83,13 @@ async function rotateBackboneV3000(molBlock: string, indices:any): Promise<strin
   }
 
   let angle = 0;
-  if (coordinates.x[first] == 0)
-    angle = coordinates.y[first] > coordinates.y[last] ? Math.PI/2 : 3*Math.PI/2;
-  else if (coordinates.y[first] == 0)
+  if (coordinates.x[first] == 0) {
+    angle = coordinates.y[first] > coordinates.y[last] ? Math.PI / 2 : 3 * Math.PI / 2;
+  } else if (coordinates.y[first] == 0) {
     angle = coordinates.x[first] > coordinates.x[last] ? Math.PI : 0;
-  else {
-    const derivative = coordinates.y[first]/coordinates.x[first];
-    if(coordinates.x[first] < coordinates.x[last])
+  } else {
+    const derivative = coordinates.y[first] / coordinates.x[first];
+    if (coordinates.x[first] < coordinates.x[last])
       angle = derivative > 0 ? Math.PI - Math.atan(derivative) : Math.atan(derivative);
     else
       angle = derivative > 0 ? Math.atan(derivative) : Math.PI - Math.atan(derivative);
@@ -106,8 +100,8 @@ async function rotateBackboneV3000(molBlock: string, indices:any): Promise<strin
 
   for (let i = 0; i < natom; i++) {
     const xAdd = coordinates.x[i];
-    coordinates.x[i] = xAdd*cos - coordinates.y[i]*sin;
-    coordinates.y[i] = xAdd*sin + coordinates.y[i]*cos;
+    coordinates.x[i] = xAdd * cos - coordinates.y[i] * sin;
+    coordinates.y[i] = xAdd * sin + coordinates.y[i] * cos;
   }
 
   //place to right
@@ -176,8 +170,6 @@ function linkV3000(monomers: any[]): string {
   macroMolBlock += 'M  V30 BEGIN CTAB\n';
   let atomBlock = '';
   let bondBlock = '';
-  let collectionBlock = '';
-  const collection: number [] = [];
   let natom = 0;
   let nbond = 0;
   let xShift = 0;
@@ -206,10 +198,10 @@ function linkV3000(monomers: any[]): string {
         //rewrite atom number
         index = molfile.indexOf('V30', index) + 4;
         indexEnd = molfile.indexOf(' ', index);
-  
-        let atomNumber = parseInt(molfile.substring(index, indexEnd))
+
+        let atomNumber = parseInt(molfile.substring(index, indexEnd));
         atomNumber = (atomNumber > remFirst && atomNumber > remLast) ? atomNumber - 2 :
-                     (atomNumber > remFirst || atomNumber > remLast) ? atomNumber - 1 : atomNumber;
+          (atomNumber > remFirst || atomNumber > remLast) ? atomNumber - 1 : atomNumber;
         atomNumber += natom;
         molfile = molfile.slice(0, index) + atomNumber + molfile.slice(indexEnd);
 
@@ -218,12 +210,12 @@ function linkV3000(monomers: any[]): string {
         index = molfile.indexOf(' ', index) + 1;
         indexEnd = molfile.indexOf(' ', index);
 
-        let coordinate = Math.round(10000*(parseFloat(molfile.substring(index, indexEnd)) + totalShift))/10000;
+        let coordinate = Math.round(10000 * (parseFloat(molfile.substring(index, indexEnd)) + totalShift)) / 10000;
         molfile = molfile.slice(0, index) + coordinate + molfile.slice(indexEnd);
 
         index = molfile.indexOf(' ', index) + 1;
         indexEnd = molfile.indexOf(' ', index);
-        coordinate = Math.round(10000*(parseFloat(molfile.substring(index, indexEnd))))/10000;
+        coordinate = Math.round(10000 * (parseFloat(molfile.substring(index, indexEnd)))) / 10000;
         molfile = molfile.slice(0, index) + coordinate + molfile.slice(indexEnd);
 
         index = molfile.indexOf('\n', index) + 1;
@@ -249,15 +241,15 @@ function linkV3000(monomers: any[]): string {
       indexEnd = molfile.indexOf(' ', index);
       bondNumber = parseInt(molfile.substring(index, indexEnd));
 
-      if(bondNumber == remBondFirst || bondNumber == remBondLast){
+      if (bondNumber == remBondFirst || bondNumber == remBondLast) {
         indexEnd = molfile.indexOf('\n', index) + 1;
-        index -=7;
+        index -= 7;
         molfile = molfile.slice(0, index) + molfile.slice(indexEnd);
-        continue
+        continue;
       }
 
       bondNumber = (bondNumber > remBondFirst && bondNumber > remBondLast) ? bondNumber - 2 :
-                   (bondNumber > remBondFirst || bondNumber > remBondLast) ? bondNumber - 1 : bondNumber;
+        (bondNumber > remBondFirst || bondNumber > remBondLast) ? bondNumber - 1 : bondNumber;
       bondNumber += nbond;
 
       molfile = molfile.slice(0, index) + bondNumber + molfile.slice(indexEnd);
@@ -266,16 +258,16 @@ function linkV3000(monomers: any[]): string {
       index = molfile.indexOf(' ', index) + 1;
       index = molfile.indexOf(' ', index) + 1;
       indexEnd = molfile.indexOf(' ', index);
-      let atomNumber = parseInt(molfile.substring(index, indexEnd))
+      let atomNumber = parseInt(molfile.substring(index, indexEnd));
       atomNumber = (atomNumber > remFirst && atomNumber > remLast) ? atomNumber - 2 :
-                   (atomNumber > remFirst || atomNumber > remLast) ? atomNumber - 1 : atomNumber;
+        (atomNumber > remFirst || atomNumber > remLast) ? atomNumber - 1 : atomNumber;
       atomNumber += natom;
       molfile = molfile.slice(0, index) + atomNumber + molfile.slice(indexEnd);
       index = molfile.indexOf(' ', index) + 1;
       indexEnd = Math.min(molfile.indexOf('\n', index), molfile.indexOf(' ', index));
-      atomNumber = parseInt(molfile.substring(index, indexEnd))
+      atomNumber = parseInt(molfile.substring(index, indexEnd));
       atomNumber = (atomNumber > remFirst && atomNumber > remLast) ? atomNumber - 2 :
-                   (atomNumber > remFirst || atomNumber > remLast) ? atomNumber - 1 : atomNumber;
+        (atomNumber > remFirst || atomNumber > remLast) ? atomNumber - 1 : atomNumber;
       atomNumber += natom;
       molfile = molfile.slice(0, index) + atomNumber + molfile.slice(indexEnd);
 
@@ -301,30 +293,30 @@ function linkV3000(monomers: any[]): string {
     nbond += numbers.nbond - 2;
     xShift += coordinates.x[last] - coordinates.x[first] + 1;
 
-    if(i == monomers.length -1){
+    if (i == monomers.length - 1) {
       natom++;
       const shift = xShift + 0.2;
       atomBlock += 'M  V30 ' + natom + ' O ' + shift + ' 0 0.000000 0\n';
     }
     nbond++;
-    if(i == monomers.length -1){
-      const rightTerminal = (last > remFirst && last > remLast) ? last + natom - (numbers.natom - 2) - 3:
-                            (last > remFirst || last > remLast) ? last + natom - (numbers.natom - 2) - 2 : 
-                            last + natom - (numbers.natom - 2) - 1;
+    if (i == monomers.length - 1) {
+      const rightTerminal = (last > remFirst && last > remLast) ? last + natom - (numbers.natom - 2) - 3 :
+        (last > remFirst || last > remLast) ? last + natom - (numbers.natom - 2) - 2 :
+          last + natom - (numbers.natom - 2) - 1;
       bondBlock += 'M  V30 ' + nbond + ' 1 ' + rightTerminal + ' ' + natom + '\n';
-    } else{
-      const rightTerminal = (last > remFirst && last > remLast) ? last + natom - (numbers.natom - 2) - 2:
-                            (last > remFirst || last > remLast) ? last + natom - (numbers.natom - 2) - 1 : 
-                            last + natom - (numbers.natom - 2);
-      
+    } else {
+      const rightTerminal = (last > remFirst && last > remLast) ? last + natom - (numbers.natom - 2) - 2 :
+        (last > remFirst || last > remLast) ? last + natom - (numbers.natom - 2) - 1 :
+          last + natom - (numbers.natom - 2);
+
       const next = monomers[i + 1]['indices'];
       const nextFirst = next['first'];
       const nextRemFirst = next['remFirst'];
       const nextRemLast = next['remLast'];
 
       const leftTerminal = (nextFirst > nextRemFirst && nextFirst > nextRemLast) ? nextFirst + natom - 2 :
-                           (nextFirst > nextRemFirst || nextFirst > nextRemLast) ? nextFirst + natom - 1 :
-                            nextFirst + natom;
+        (nextFirst > nextRemFirst || nextFirst > nextRemLast) ? nextFirst + natom - 1 :
+          nextFirst + natom;
 
       bondBlock += 'M  V30 ' + nbond + ' 1 ' + rightTerminal + ' ' + leftTerminal + '\n';
     }

package/src/utils/cell-renderer.ts

@@ -61,7 +61,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
 
   get defaultWidth(): number | null { return 230; }
 
-  onClick(gridCell: DG.GridCell, e: MouseEvent): void {
+  onClick(gridCell: DG.GridCell, _e: MouseEvent): void {
     const colTemp: TempType = gridCell.cell.column.temp;
     colTemp[tempTAGS.currentWord] = gridCell.cell.value;
     gridCell.grid.invalidate();
@@ -112,12 +112,12 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
    * @param {number} w width of the cell.
    * @param {number} h height of the cell.
    * @param {DG.GridCell} gridCell Grid cell.
-   * @param {DG.GridCellStyle} cellStyle Cell style.
+   * @param {DG.GridCellStyle} _cellStyle Cell style.
    * @memberof AlignedSequenceCellRenderer
    */
   render(
-    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
-    cellStyle: DG.GridCellStyle
+    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;
@@ -251,6 +251,21 @@ export class MonomerCellRenderer extends DG.GridCellRenderer {
     g.fillStyle = color;
     g.fillText(monomerToShort(s, 3), x + (w / 2), y + (h / 2), w);
   }
+
+  svgMolOptions = {autoCrop: true, autoCropMargin: 0, suppressChiralText: true};
+
+  onMouseEnter(gridCell: DG.GridCell, e: MouseEvent) {
+    super.onMouseEnter(gridCell, e);
+
+    // TODO: Display monomer structure within tooltip
+    // const monomerName = gridCell.cell.value;
+    // const mw = getMonomerWorksInstance();
+    // // TODO: Display monomer structure in Tooltip
+    // const nameDiv = ui.div(monomerName);
+    // const molDiv = grok.chem.svgMol(monomerMol, undefined, undefined, svgMolOptions);
+    //
+    // ui.tooltip.show(ui.divV([nameDiv, molEl,]), x, y);
+  }
 }
 
 export class MacromoleculeDifferenceCellRenderer extends DG.GridCellRenderer {
@@ -302,7 +317,7 @@ export function drawMoleculeDifferenceOnCanvas(
   subParts2: string [],
   units: string,
   fullStringLength?: boolean,
-  molDifferences?: { [key: number]: HTMLCanvasElement }
+  molDifferences?: { [key: number]: HTMLCanvasElement },
 ): void {
   if (subParts1.length !== subParts2.length) {
     const sequences: IComparedSequences = fillShorterSequence(subParts1, subParts2);
@@ -382,7 +397,7 @@ function fillShorterSequence(subParts1: string[], subParts2: string[]): ICompare
   let numIdenticalStart = 0;
   let numIdenticalEnd = 0;
   const longerSeq = subParts1.length > subParts2.length ? subParts1 : subParts2;
-  let shorterSeq = subParts1.length > subParts2.length ? subParts2 : subParts1;
+  const shorterSeq = subParts1.length > subParts2.length ? subParts2 : subParts1;
 
   for (let i = 0; i < shorterSeq.length; i++) {
     if (longerSeq[i] === shorterSeq[i])
@@ -398,9 +413,11 @@ function fillShorterSequence(subParts1: string[], subParts2: string[]): ICompare
   const emptyMonomersArray = new Array<string>(Math.abs(subParts1.length - subParts2.length)).fill('');
 
   function concatWithEmptyVals(subparts: string[]): string[] {
-    return numIdenticalStart > numIdenticalEnd ? subparts.concat(emptyMonomersArray) : emptyMonomersArray.concat(subparts);
+    return numIdenticalStart > numIdenticalEnd ?
+      subparts.concat(emptyMonomersArray) : emptyMonomersArray.concat(subparts);
   }
 
-  subParts1.length > subParts2.length ? subParts2 = concatWithEmptyVals(subParts2) : subParts1 = concatWithEmptyVals(subParts1);
+  subParts1.length > subParts2.length ?
+    subParts2 = concatWithEmptyVals(subParts2) : subParts1 = concatWithEmptyVals(subParts1);
   return {subParts1: subParts1, subParts2: subParts2};
 }

package/src/utils/check-input-column.ts

@@ -4,7 +4,15 @@ import * as ui from 'datagrok-api/ui';
 
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
-/** */
+/**
+ * Checks if the column is suitable for the analysis.
+ * @param {DG.Column} col macromolecule coulumn.
+ * @param {string} name column name
+ * @param {string[]} allowedNotations allowed notations
+ * @param {string[]} allowedAlphabets allowed alphabets
+ * @param {boolean} notify show warning message if the column is not suitable for the analysis
+ * @return {boolean} True if the column is suitable for the analysis.
+ */
 export function checkInputColumnUI(col: DG.Column, name: string, allowedNotations: string[] = [],
   allowedAlphabets: string[] = [], notify: boolean = true): boolean {
   const [res, msg]: [boolean, string] = checkInputColumn(col, name, allowedNotations, allowedAlphabets);
@@ -13,14 +21,21 @@ export function checkInputColumnUI(col: DG.Column, name: string, allowedNotation
   return res;
 }
 
-/** */
+/**
+ * Checks if the column is suitable for the analysis.
+ * @param {DG.Column} col macromolecule coulumn.
+ * @param {string} name column name
+ * @param {string[]} allowedNotations allowed notations
+ * @param {string[]} allowedAlphabets allowed alphabets
+ * @return {[boolean, string]} [True if the column is suitable for the analysis, warning message].
+ */
 export function checkInputColumn(
-  col: DG.Column, name: string, allowedNotations: string[] = [], allowedAlphabets: string[] = []
+  col: DG.Column, name: string, allowedNotations: string[] = [], allowedAlphabets: string[] = [],
 ): [boolean, string] {
   let res: boolean = true;
   let msg: string = '';
 
-  const uh = new UnitsHandler(col);
+  const uh = UnitsHandler.getOrCreate(col);
   if (col.semType !== DG.SEMTYPE.MACROMOLECULE) {
     grok.shell.warning(name + ' analysis is allowed for Macromolecules semantic type');
     res = false;

package/src/utils/constants.ts

@@ -70,8 +70,8 @@ export const msaDefaultOptions = {
     method: pepseaMethods[0],
   },
   kalign: {
-    gapOpen: null,
-    gapExtend: null,
-    terminalGap: null,
+    gapOpen: -1.0,
+    gapExtend: -1.0,
+    terminalGap: -1.0,
   },
 } as const;

package/src/utils/convert.ts

@@ -16,18 +16,56 @@ let convertDialogSubs: Subscription[] = [];
  *
  * @param {DG.column} col Column with 'Macromolecule' semantic type
  */
-export function convert(col: DG.Column): void {
-  const converter = new NotationConverter(col);
-  const currentNotation: NOTATION = converter.notation;
-  //TODO: read all notations
+export function convert(col?: DG.Column): void {
+
+  let tgtCol = col ?? grok.shell.t.columns.bySemType('Macromolecule')!;
+  if (!tgtCol)
+    throw new Error('No column with Macromolecule semantic type found');
+  let converter = new NotationConverter(tgtCol);
+  let currentNotation: NOTATION = converter.notation;
+  const dialogHeader =  ui.divText(
+    'Current notation: ' + currentNotation,
+    {
+      style: {
+        'text-align': 'center',
+        'font-weight': 'bold',
+        'font-size': '14px',
+        'padding': '5px',
+      },
+    },
+  );
   const notations = [
     NOTATION.FASTA,
     NOTATION.SEPARATOR,
-    NOTATION.HELM
+    NOTATION.HELM,
   ];
+  const toggleColumn = (newCol: DG.Column) => {
+    if (newCol.semType !== DG.SEMTYPE.MACROMOLECULE) {
+      targetColumnInput.value = tgtCol;
+      return;
+    }
+
+    tgtCol = newCol;
+    converter = new NotationConverter(tgtCol);
+    currentNotation = converter.notation;
+    dialogHeader.textContent = 'Current notation: ' + currentNotation;
+    filteredNotations = notations.filter((e) => e !== currentNotation);
+    targetNotationInput = ui.choiceInput('Convert to', filteredNotations[0], filteredNotations);
+    toggleSeparator();
+    convertDialog?.clear();
+    convertDialog?.add(ui.div([
+      dialogHeader,
+      targetColumnInput.root,
+      targetNotationInput.root,
+      separatorInput.root
+    ]))
+  };
+
+  const targetColumnInput = ui.columnInput('Column', grok.shell.t, tgtCol, toggleColumn);
+
   const separatorArray = ['-', '.', '/'];
-  const filteredNotations = notations.filter((e) => e !== currentNotation);
-  const targetNotationInput = ui.choiceInput('Convert to', filteredNotations[0], filteredNotations);
+  let filteredNotations = notations.filter((e) => e !== currentNotation);
+  let targetNotationInput = ui.choiceInput('Convert to', filteredNotations[0], filteredNotations);
 
   const separatorInput = ui.choiceInput('Separator', separatorArray[0], separatorArray);
 
@@ -49,29 +87,20 @@ export function convert(col: DG.Column): void {
   if (convertDialog == null) {
     convertDialog = ui.dialog('Convert Sequence Notation')
       .add(ui.div([
-        ui.divText(
-          'Current notation: ' + currentNotation,
-          {
-            style: {
-              'text-align': 'center',
-              'font-weight': 'bold',
-              'font-size': '14px',
-              'padding': '5px',
-            }
-          }
-        ),
+        dialogHeader,
+        targetColumnInput.root,
         targetNotationInput.root,
-        separatorInput.root
+        separatorInput.root,
       ]))
       .onOK(async () => {
         const targetNotation = targetNotationInput.value as NOTATION;
         const separator: string | null = separatorInput.value;
 
-        await convertDo(col, targetNotation, separator);
+        await convertDo(tgtCol, targetNotation, separator);
       })
       .show({x: 350, y: 100});
 
-    convertDialogSubs.push(convertDialog.onClose.subscribe((value) => {
+    convertDialogSubs.push(convertDialog.onClose.subscribe((_value) => {
       convertDialogSubs.forEach((s) => { s.unsubscribe(); });
       convertDialogSubs = [];
       convertDialog = null;
@@ -79,9 +108,13 @@ export function convert(col: DG.Column): void {
   }
 }
 
-/** Creates a new column with converted sequences and detects its semantic type */
+/** Creates a new column with converted sequences and detects its semantic type
+ * @param {DG.Column} srcCol Column with 'Macromolecule' semantic type
+ * @param {NOTATION} targetNotation Target notation
+ * @param {string | null} separator Separator for SEPARATOR notation
+ */
 export async function convertDo(
-  srcCol: DG.Column, targetNotation: NOTATION, separator: string | null
+  srcCol: DG.Column, targetNotation: NOTATION, separator: string | null,
 ): Promise<DG.Column> {
   const converter = new NotationConverter(srcCol);
   const newColumn = converter.convert(targetNotation, separator);