@datagrok/bio 1.5.10 → 1.7.1

package/src/package.ts

@@ -19,6 +19,10 @@ import {sequenceGetSimilarities, drawTooltip} from './utils/sequence-activity-cl
 import {getMolfilesFromSeq, HELM_CORE_LIB_FILENAME} from './utils/utils';
 import {getMacroMol} from './utils/atomic-works';
 import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
+import {Column} from 'datagrok-api/dg';
+import {SEM_TYPES} from './utils/constants';
+import { delay } from '@datagrok-libraries/utils/src/test';
+import { TableView } from 'datagrok-api/dg';
 
 //tags: init
 export async function initBio(): Promise<void> {
@@ -38,6 +42,29 @@ export function macromoleculeSequenceCellRenderer(): MacromoleculeSequenceCellRe
   return new MacromoleculeSequenceCellRenderer();
 }
 
+function checkInputColumn(col: DG.Column, name: string,
+  allowedNotations: string[] = [], allowedAlphabets: string[] = []): boolean {
+  const units: string = col.getTag(DG.TAGS.UNITS);
+  if (col.semType !== DG.SEMTYPE.MACROMOLECULE) {
+    grok.shell.warning(name + ' analysis is allowed for Macromolecules semantic type');
+    return false;
+  } else if (
+    (allowedAlphabets.length > 0 &&
+      !allowedAlphabets.some((a) => units.toUpperCase().endsWith(a.toUpperCase()))) ||
+    (allowedNotations.length > 0 &&
+      !allowedNotations.some((n) => units.toUpperCase().startsWith(n.toUpperCase())))
+  ) {
+    const notationAdd = allowedNotations.length == 0 ? 'any notation' :
+      (`notation${allowedNotations.length > 1 ? 's' : ''} ${allowedNotations.map((n) => `"${n}"`).join(', ')} `);
+    const alphabetAdd = allowedNotations.length == 0 ? 'any alphabet' :
+      (`alphabet${allowedAlphabets.length > 1 ? 's' : ''} ${allowedAlphabets.map((a) => `"${a}"`).join(', ')}.`);
+
+    grok.shell.warning(name + ' analysis is allowed for Macromolecules with ' + notationAdd + ' and ' + alphabetAdd);
+    return false;
+  }
+
+  return true;
+}
 
 //name: sequenceAlignment
 //input: string alignType {choices: ['Local alignment', 'Global alignment']}
@@ -73,20 +100,23 @@ export function vdRegionViewer() {
 //name: Sequence Activity Cliffs
 //description: detect activity cliffs
 //input: dataframe table [Input data table]
-//input: column sequence {semType: Macromolecule}
+//input: column macroMolecule {semType: Macromolecule}
 //input: column activities
 //input: double similarity = 80 [Similarity cutoff]
 //input: string methodName { choices:["UMAP", "t-SNE", "SPE"] }
-export async function activityCliffs(df: DG.DataFrame, sequence: DG.Column, activities: DG.Column,
+export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column, activities: DG.Column,
   similarity: number, methodName: string): Promise<void> {
+  if (!checkInputColumn(macroMolecule, 'Activity Cliffs'))
+    return;
+
   const axesNames = getEmbeddingColsNames(df);
   const options = {
     'SPE': {cycles: 2000, lambda: 1.0, dlambda: 0.0005},
   };
-  const units = sequence!.tags[DG.TAGS.UNITS];
+  const units = macroMolecule!.tags[DG.TAGS.UNITS];
   await getActivityCliffs(
     df,
-    sequence,
+    macroMolecule,
     axesNames,
     'Activity cliffs',
     activities,
@@ -110,6 +140,9 @@ export async function activityCliffs(df: DG.DataFrame, sequence: DG.Column, acti
 //input: bool plotEmbeddings = true
 export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: DG.Column, methodName: string,
   similarityMetric: string = 'Levenshtein', plotEmbeddings: boolean): Promise<void> {
+  if (!checkInputColumn(macroMolecule, 'Activity Cliffs'))
+    return;
+
   const embedColsNames = getEmbeddingColsNames(table);
   const chemSpaceParams = {
     seqCol: macroMolecule,
@@ -133,22 +166,40 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
 //name: To Atomic Level
 //description: returns molfiles for each monomer from HELM library
 //input: dataframe df [Input data table]
-//input: column sequence {semType: Macromolecule}
-export async function toAtomicLevel(df: DG.DataFrame, sequence: DG.Column): Promise<void> {
-  if (DG.Func.find({package: 'Chem', name: 'getRdKitModule'})) {
+//input: column macroMolecule {semType: Macromolecule}
+export async function toAtomicLevel(df: DG.DataFrame, macroMolecule: DG.Column): Promise<void> {
+  if (DG.Func.find({package: 'Chem', name: 'getRdKitModule'}).length === 0) {
     grok.shell.warning('Transformation to atomic level requires package "Chem" installed.');
     return;
   }
+  if (!checkInputColumn(macroMolecule, 'To Atomic Level'))
+    return;
 
+  let currentView: TableView;
+  for (let view of grok.shell.tableViews) {
+    if (df.name === view.name) {
+      currentView = view;
+    }
+  }
+  const file = await _package.files.readAsText('tests/sar-small.csv');
+  const df2 = DG.DataFrame.fromCsv(file);
+  const v = grok.shell.addTableView(df2);
+  setTimeout(()=> {
+    grok.shell.closeTable(df2);
+    v.close();
+    grok.shell.v = currentView;
+  }, 100);
+  
   const monomersLibFile = await _package.files.readAsText(HELM_CORE_LIB_FILENAME);
   const monomersLibObject: any[] = JSON.parse(monomersLibFile);
-  const atomicCodes = getMolfilesFromSeq(sequence, monomersLibObject);
+  const atomicCodes = getMolfilesFromSeq(macroMolecule, monomersLibObject);
   const result = await getMacroMol(atomicCodes!);
 
   const col = DG.Column.fromStrings('regenerated', result);
   col.semType = DG.SEMTYPE.MOLECULE;
   col.tags[DG.TAGS.UNITS] = 'molblock';
-  df.columns.add(col);
+  df.columns.add(col, true);
+
 }
 
 
@@ -158,21 +209,8 @@ export async function toAtomicLevel(df: DG.DataFrame, sequence: DG.Column): Prom
 //input: column sequence { semType: Macromolecule }
 //output: column result
 export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.Column): Promise<DG.Column | null> {
-  if (col.semType != DG.SEMTYPE.MACROMOLECULE) {
-    grok.shell.warning(`MSA analysis is allowed for semantic type "${DG.SEMTYPE.MACROMOLECULE}" data only.`);
+  if (!checkInputColumn(col, 'MSA', ['fasta'], ['DNA', 'RNA', 'PT']))
     return null;
-  }
-  const units: string = col.getTag(DG.TAGS.UNITS);
-  const allowedAlphabets = ['DNA', 'RNA', 'PT'];
-  const allowedNotations = ['fasta'];
-  if (!allowedAlphabets.some((a) => units.toUpperCase().endsWith(a.toUpperCase())) ||
-    !allowedNotations.some((n) => units.toUpperCase().startsWith(n.toUpperCase()))) {
-    grok.shell.warning('MSA analysis is allowed for ' +
-      `notation${allowedNotations.length > 1 ? 's' : ''} ${allowedNotations.map((n) => `"${n}"`).join(', ')} ` +
-      'and ' +
-      `alphabet${allowedAlphabets.length > 1 ? 's' : ''} ${allowedAlphabets.map((a) => `"${a}"`).join(', ')}.`);
-    return null;
-  }
 
   const msaCol = await runKalign(col, false);
   table.columns.add(msaCol);
@@ -199,6 +237,9 @@ export async function compositionAnalysis(): Promise<void> {
     return;
   }
 
+  if (!checkInputColumn(col, 'Composition'))
+    return;
+
   const allowedNotations: string[] = ['fasta', 'separator'];
   const units = col.getTag(DG.TAGS.UNITS);
   if (!allowedNotations.some((n) => units.toUpperCase().startsWith(n.toUpperCase()))) {
@@ -224,7 +265,7 @@ function parseMacromolecule(
 //name: importFasta
 //description: Opens FASTA file
 //tags: file-handler
-//meta.ext: fasta, fna, ffn, faa, frn, fa
+//meta.ext: fasta, fna, ffn, faa, frn, fa, fst
 //input: string fileContent
 //output: list tables
 export function importFasta(fileContent: string): DG.DataFrame [] {
@@ -244,13 +285,34 @@ export function importFasta(fileContent: string): DG.DataFrame [] {
   const descriptionsArrayCol = DG.Column.fromStrings('description', descriptionsArray);
   const sequenceCol = DG.Column.fromStrings('sequence', sequencesArray);
   sequenceCol.semType = 'Macromolecule';
-
   const stats: SeqColStats = WebLogo.getStats(sequenceCol, 5, WebLogo.splitterAsFasta);
   const seqType = stats.sameLength ? 'SEQ.MSA' : 'SEQ';
+
+  const PeptideFastaAlphabet = new Set([
+    'G', 'L', 'Y', 'S', 'E', 'Q', 'D', 'N', 'F', 'A',
+    'K', 'R', 'H', 'C', 'V', 'P', 'W', 'I', 'M', 'T',
+  ]);
+
+  const DnaFastaAlphabet = new Set(['A', 'C', 'G', 'T']);
+
+  const RnaFastaAlphabet = new Set(['A', 'C', 'G', 'U']);
+
+  //const SmilesRawAlphabet = new Set([
+  //  'O', 'C', 'c', 'N', 'S', 'F', '(', ')',
+  //  '1', '2', '3', '4', '5', '6', '7',
+  //  '+', '-', '@', '[', ']', '/', '\\', '#', '=']);
+
   const alphabetCandidates: [string, Set<string>][] = [
-    ['NT', new Set(Object.keys(Nucleotides.Names))],
-    ['PT', new Set(Object.keys(Aminoacids.Names))],
+    ['PT', PeptideFastaAlphabet],
+    ['DNA', DnaFastaAlphabet],
+    ['RNA', RnaFastaAlphabet],
   ];
+
+  //const alphabetCandidates: [string, Set<string>][] = [
+  //  ['NT', new Set(Object.keys(Nucleotides.Names))],
+  //  ['PT', new Set(Object.keys(Aminoacids.Names))],
+  //];
+
   // Calculate likelihoods for alphabet_candidates
   const alphabetCandidatesSim: number[] = alphabetCandidates.map(
     (c) => WebLogo.getAlphabetSimilarity(stats.freq, c[1]));

package/src/tests/convert-test.ts

@@ -22,6 +22,10 @@ category('converters', () => {
     fastaRna = 'fastaRna',
     separatorRna = 'separatorRna',
     helmRna = 'helmRna',
+
+    fastaGaps = 'fastaGaps',
+    separatorGaps = 'separatorGaps',
+    helmGaps = 'helmGaps'
   }
 
   const _csvTxts: { [key: string]: string } = {
@@ -44,7 +48,7 @@ PEPTIDE1{M.K.P.S.E.Y.V}$$$
 ACGTC
 CAGTGT
 TTCAAC
-    `,
+`,
     separatorDna: `seq
 A/C/G/T/C
 C/A/G/T/G/T
@@ -59,7 +63,7 @@ DNA1{D(T)P.D(T)P.D(C)P.D(A)P.D(A)P.D(C)P}$$$
 ACGUC
 CAGUGU
 UUCAAC
-    `,
+`,
     separatorRna: `seq
 A*C*G*U*C
 C*A*G*U*G*U
@@ -69,6 +73,24 @@ U*U*C*A*A*C
 RNA1{R(A)P.R(C)P.R(G)P.R(U)P.R(C)P}$$$
 RNA1{R(C)P.R(A)P.R(G)P.R(U)P.R(G)P.R(U)P}$$$
 RNA1{R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P}$$$
+`,
+
+    fastaGaps: `seq
+FW-PH-EY
+-YNRQWYV-
+MKP---SEYV
+`,
+
+    separatorGaps: `seq
+F/W//P/H//E/Y
+//Y/N/R/Q/W/Y/V//
+M/K/P////S/E/Y/V
+`,
+
+    helmGaps: `seq
+PEPTIDE1{F.W.*.P.H.*.E.Y}$$$
+PEPTIDE1{*.Y.N.R.Q.W.Y.V.*}$$$
+PEPTIDE1{M.K.P.*.*.*.S.E.Y.V}$$$
 `,
   };
 
@@ -90,10 +112,10 @@ RNA1{R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P}$$$
     return _csvDfs[key];
   };
 
-  function converter(tgtNotation: NOTATION, separator: string | null = null): ConverterFunc {
+  function converter(tgtNotation: NOTATION, tgtSeparator: string | null = null): ConverterFunc {
     return function(srcCol: DG.Column): DG.Column {
       const converter = new NotationConverter(srcCol);
-      const resCol = converter.convert(NOTATION.SEPARATOR, separator);
+      const resCol = converter.convert(tgtNotation, tgtSeparator);
       return resCol;
     };
   };
@@ -110,6 +132,7 @@ RNA1{R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P}$$$
     expectArray(resCol.toList(), tgtCol.toList());
   }
 
+  // FASTA tests
   test('testFastaPtToSeparator', async () => {
     await _testConvert(Samples.fastaPt, converter(NOTATION.SEPARATOR, '-'), Samples.separatorPt);
   });
@@ -127,26 +150,44 @@ RNA1{R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P}$$$
     await _testConvert(Samples.fastaDna, converter(NOTATION.HELM), Samples.helmDna);
   });
   test('testFastaRnaToHelm', async () => {
-    await _testConvert(Samples.fastaDna, converter(NOTATION.HELM), Samples.helmRna);
+    await _testConvert(Samples.fastaRna, converter(NOTATION.HELM), Samples.helmRna);
   });
 
+  test('testFastaGapsToSeparator', async () => {
+    await _testConvert(Samples.fastaGaps, converter(NOTATION.SEPARATOR, '/'), Samples.separatorGaps);
+  });
+  test('testFastaGapsToHelm', async () => {
+    await _testConvert(Samples.fastaGaps, converter(NOTATION.SEPARATOR), Samples.helmGaps);
+  });
+
+
+  // SEPARATOR tests
   test('testSeparatorPtToFasta', async () => {
     await _testConvert(Samples.separatorPt, converter(NOTATION.FASTA), Samples.fastaPt);
   });
   test('testSeparatorDnaToFasta', async () => {
     await _testConvert(Samples.separatorDna, converter(NOTATION.FASTA), Samples.fastaDna);
   });
-  test('testSeparatorDnaToFasta', async () => {
+  test('testSeparatorRnaToFasta', async () => {
     await _testConvert(Samples.separatorRna, converter(NOTATION.FASTA), Samples.fastaRna);
   });
 
   test('testSeparatorPtToHelm', async () => {
-    await _testConvert(Samples.separatorRna, converter(NOTATION.HELM), Samples.helmPt);
+    await _testConvert(Samples.separatorPt, converter(NOTATION.HELM), Samples.helmPt);
   });
   test('testSeparatorDnaToHelm', async () => {
-    await _testConvert(Samples.separatorRna, converter(NOTATION.HELM), Samples.helmDna);
+    await _testConvert(Samples.separatorDna, converter(NOTATION.HELM), Samples.helmDna);
   });
   test('testSeparatorRnaToHelm', async () => {
     await _testConvert(Samples.separatorRna, converter(NOTATION.HELM), Samples.helmRna);
   });
+  test('testSeparatorGapsToFasta', async () => {
+    await _testConvert(Samples.separatorGaps, converter(NOTATION.FASTA), Samples.fastaGaps);
+  });
+  test('testSeparatorGapsToHelm', async () => {
+    await _testConvert(Samples.separatorGaps, converter(NOTATION.HELM), Samples.helmGaps);
+  });
+
+
+  // HELM tests: TODO
 });

package/src/tests/detectors-test.ts

@@ -104,6 +104,7 @@ MWRSWY-CKHP
     peptidesComplex = 'peptidesComplex',
     fastaCsv = 'fastaCsv',
     fastaFasta = 'fastaFasta',
+    fastaPtCsv = 'fastaPtCsv',
     msaComplex = 'msaComplex',
     helmCsv = 'helmCsv',
     testDemogCsv = 'testDemogCsv',
@@ -114,16 +115,17 @@ MWRSWY-CKHP
   }
 
   const samples: { [key: string]: string } = {
-    'peptidesComplex': 'System:AppData/Bio/samples/peptides_complex_msa.csv',
+    'peptidesComplex': 'System:AppData/Bio/tests/peptides_complex_msa.csv',
     'fastaCsv': 'System:AppData/Bio/samples/sample_FASTA.csv',
     'fastaFasta': 'System:AppData/Bio/samples/sample_FASTA.fasta',
+    'fastaPtCsv': 'System:AppData/Bio/samples/sample_FASTA_PT.csv',
     'msaComplex': 'System:AppData/Bio/samples/sample_MSA.csv',
     'helmCsv': 'System:AppData/Bio/samples/sample_HELM.csv',
-    'testDemogCsv': 'System:AppData/Bio/samples/testDemog.csv',
-    'testHelmCsv': 'System:AppData/Bio/samples/testHelm.csv',
-    'testIdCsv': 'System:AppData/Bio/samples/id.csv',
-    'testSmilesCsv': 'System:AppData/Bio/samples/testSmiles.csv',
-    'testSmiles2Csv': 'System:AppData/Bio/samples/testSmiles2.csv',
+    'testDemogCsv': 'System:AppData/Bio/tests/testDemog.csv',
+    'testHelmCsv': 'System:AppData/Bio/tests/testHelm.csv',
+    'testIdCsv': 'System:AppData/Bio/tests/id.csv',
+    'testSmilesCsv': 'System:AppData/Bio/tests/testSmiles.csv',
+    'testSmiles2Csv': 'System:AppData/Bio/tests/testSmiles2.csv',
   };
 
   const _samplesDfs: { [key: string]: Promise<DG.DataFrame> } = {};
@@ -294,6 +296,10 @@ MWRSWY-CKHP
   test('samplesTestSmiles2NegativeSmiles', async () => {
     await _testNeg(readSamples(Samples.testSmiles2Csv), 'SMILES');
   });
+
+  test('samplesFastaPtPosSequence', async () => {
+    await (_testPos(readSamples(Samples.fastaPtCsv), 'sequence', 'fasta:SEQ:PT'));
+  });
 });
 
 export async function _testNeg(readDf: DfReaderFunc, colName: string) {

package/src/utils/cell-renderer.ts

@@ -1,33 +1,36 @@
-import * as C from "./constants";
-import {getSeparator} from "./misc";
-import {ChemPalette} from "./chem-palette";
+import * as C from './constants';
 import * as DG from 'datagrok-api/dg';
-import {AminoacidsPalettes} from "@datagrok-libraries/bio/src/aminoacids";
-import {NucleotidesPalettes} from "@datagrok-libraries/bio/src/nucleotides";
-import {UnknownSeqPalettes} from "@datagrok-libraries/bio/src/unknown";
-import {SplitterFunc, WebLogo} from "@datagrok-libraries/bio/src/viewers/web-logo";
-import {SeqPalette} from "@datagrok-libraries/bio/src/seq-palettes";
+import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
+import {NucleotidesPalettes} from '@datagrok-libraries/bio/src/nucleotides';
+import {UnknownSeqPalettes} from '@datagrok-libraries/bio/src/unknown';
+import {SplitterFunc, WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import * as ui from 'datagrok-api/ui';
 
 const lru = new DG.LruCache<any, any>();
+const undefinedColor = 'rgb(100,100,100)';
 
-function getPalleteByType(paletteType: string): SeqPalette  {
+function getPalleteByType(paletteType: string): SeqPalette {
   switch (paletteType) {
-    case 'PT':
-      return  AminoacidsPalettes.GrokGroups;
-    case 'NT':
-      return  NucleotidesPalettes.Chromatogram
-      // other
-    default:
-      return UnknownSeqPalettes.Color;
+  case 'PT':
+    return AminoacidsPalettes.GrokGroups;
+  case 'NT':
+    return NucleotidesPalettes.Chromatogram;
+  case 'DNA':
+    return NucleotidesPalettes.Chromatogram;
+  case 'RNA':
+    return NucleotidesPalettes.Chromatogram;
+    // other
+  default:
+    return UnknownSeqPalettes.Color;
   }
 }
 
 export function processSequence(subParts: string[]): [string[], boolean] {
   const simplified = !subParts.some((amino, index) =>
-      amino.length > 1 &&
-      index != 0 &&
-      index != subParts.length - 1);
+    amino.length > 1 &&
+    index != 0 &&
+    index != subParts.length - 1);
 
   const text: string[] = [];
   const gap = simplified ? '' : ' ';
@@ -39,6 +42,7 @@ export function processSequence(subParts: string[]): [string[], boolean] {
   });
   return [text, simplified];
 }
+
 /**
  * A function that prints a string aligned to left or centered.
  *
@@ -48,21 +52,25 @@ export function processSequence(subParts: string[]): [string[], boolean] {
  * @param {number} h Height.
  * @param {CanvasRenderingContext2D} g Canvas rendering context.
  * @param {string} s String to print.
- * @param {string} [color=ChemPalette.undefinedColor] String color.
+ * @param {string} [color=undefinedColor] String color.
  * @param {number} [pivot=0] Pirvot.
  * @param {boolean} [left=false] Is left aligned.
- * @param {boolean} [hideMod=false] Hide amino acid redidue modifications.
  * @param {number} [transparencyRate=0.0] Transparency rate where 1.0 is fully transparent
+ * @param {string} [separator=''] Is separator for sequence.
+ * @param {boolean} [last=false] Is checker if element last or not.
  * @return {number} x coordinate to start printing at.
  */
 function printLeftOrCentered(
-    x: number, y: number, w: number, h: number,
-    g: CanvasRenderingContext2D, s: string, color = ChemPalette.undefinedColor,
-    pivot: number = 0, left = false, hideMod = false, transparencyRate: number = 1.0,
-    separator: string = ''): number {
+  x: number, y: number, w: number, h: number,
+  g: CanvasRenderingContext2D, s: string, color = undefinedColor,
+  pivot: number = 0, left = false, transparencyRate: number = 1.0,
+  separator: string = '', last: boolean = false): number {
   g.textAlign = 'start';
-  let colorPart = s.substring(0);
+  const colorPart = s.substring(0);
   let grayPart = separator;
+  if (last) {
+    grayPart = '';
+  }
   const textSize = g.measureText(colorPart + grayPart);
   const indent = 5;
 
@@ -87,54 +95,12 @@ function printLeftOrCentered(
     return x + dx + colorTextSize.width;
   }
 }
-function renderSequense(
-      g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
-      cellStyle: DG.GridCellStyle,
-): void {
-    const grid = gridCell.grid;
-    const cell = gridCell.cell;
-    const [type, subtype, paletteType] =  gridCell.cell.column.getTag(DG.TAGS.UNITS).split(":");
-    w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
-    g.save();
-    g.beginPath();
-    g.rect(x, y, w, h);
-    g.clip();
-    g.font = '12px monospace';
-    g.textBaseline = 'top';
-    const s: string = cell.value ?? '';
-
-  //TODO: can this be replaced/merged with splitSequence?
-  const units = gridCell.cell.column.getTag(DG.TAGS.UNITS);
-
-  const palette = getPalleteByType(paletteType);
-
-  const separator = gridCell.cell.column.getTag('separator') ?? '';
-  const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, gridCell.cell.column.getTag('separator') );// splitter,
-
-  const subParts:string[] =  splitterFunc(cell.value);
-
-  const textSize = g.measureText(subParts.join(''));
-  let x1 = Math.max(x, x + (w - textSize.width) / 2);
-
-  subParts.forEach((amino, index) => {
-    let [color, outerAmino,, pivot] = ChemPalette.getColorAAPivot(amino);
-    color = palette.get(amino);
-    g.fillStyle = ChemPalette.undefinedColor;
-    x1 = printLeftOrCentered(x1, y, w, h, g, amino, color, pivot, true, false, 1.0, separator);
-  });
-
-  g.restore();
-}
 
 export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
-
-  get name(): string {return 'macromoleculeSequence';}
-
-  get cellType(): string {return C.SEM_TYPES.Macro_Molecule;}
-
-  get defaultHeight(): number {return 30;}
-
-  get defaultWidth(): number {return 230;}
+  get name(): string { return 'macromoleculeSequence'; }
+  get cellType(): string { return C.SEM_TYPES.Macro_Molecule; }
+  get defaultHeight(): number { return 30; }
+  get defaultWidth(): number { return 230; }
 
   /**
    * Cell renderer function.
@@ -149,32 +115,32 @@ 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,
+    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
+    cellStyle: DG.GridCellStyle
   ): void {
     const grid = gridCell.grid;
     const cell = gridCell.cell;
     const tag = gridCell.cell.column.getTag(DG.TAGS.UNITS);
     if (tag === 'HELM') {
-      let host = ui.div([], { style: { width: `${w}px`, height: `${h}px`}});
+      const host = ui.div([], {style: {width: `${w}px`, height: `${h}px`}});
       host.setAttribute('dataformat', 'helm');
       host.setAttribute('data', gridCell.cell.value);
       gridCell.element = host;
       //@ts-ignore
-      var canvas = new JSDraw2.Editor(host, { width: w, height: h, skin: "w8", viewonly: true });
-      var formula = canvas.getFormula(true);
+      const canvas = new JSDraw2.Editor(host, {width: w, height: h, skin: 'w8', viewonly: true});
+      const formula = canvas.getFormula(true);
       if (!formula) {
         gridCell.element = ui.divText(gridCell.cell.value, {style: {color: 'red'}});
       } else {
         gridCell.element = host;
-        var molWeight = Math.round(canvas.getMolWeight() * 100) / 100;
-        var coef = Math.round(canvas.getExtinctionCoefficient(true) * 100) / 100;
-        var molfile = canvas.getMolfile();
-        var result = formula + ', ' + molWeight + ', ' + coef + ', ' + molfile;
+        const molWeight = Math.round(canvas.getMolWeight() * 100) / 100;
+        const coef = Math.round(canvas.getExtinctionCoefficient(true) * 100) / 100;
+        const molfile = canvas.getMolfile();
+        const result = formula + ', ' + molWeight + ', ' + coef + ', ' + molfile;
         lru.set(gridCell.cell.value, result);
       }
     } else {
-      const [type, subtype, paletteType] =  gridCell.cell.column.getTag(DG.TAGS.UNITS).split(":");
+      const [type, subtype, paletteType] = gridCell.cell.column.getTag(DG.TAGS.UNITS).split(':');
       w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
       g.save();
       g.beginPath();
@@ -190,19 +156,20 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
       const palette = getPalleteByType(paletteType);
 
       const separator = gridCell.cell.column.getTag('separator') ?? '';
-      const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, gridCell.cell.column.getTag('separator') );// splitter,
+      const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, gridCell.cell.column.getTag('separator'));
 
-      const subParts:string[] =  splitterFunc(cell.value);
+      const subParts: string[] = splitterFunc(cell.value);
       // console.log(subParts);
-
-      const textSize = g.measureText(subParts.join(''));
-      let x1 = Math.max(x, x + (w - textSize.width) / 2);
-
+      let x1 = x;
+      let color = undefinedColor;
       subParts.forEach((amino, index) => {
-        let [color, outerAmino,, pivot] = ChemPalette.getColorAAPivot(amino);
         color = palette.get(amino);
-        g.fillStyle = ChemPalette.undefinedColor;
-        x1 = printLeftOrCentered(x1, y, w, h, g, amino, color, pivot, true, false, 1.0, separator);
+        g.fillStyle = undefinedColor;
+        let last = false;
+        if (index === subParts.length - 1) {
+          last = true;
+        }
+        x1 = printLeftOrCentered(x1, y, w, h, g, amino, color, 0, true, 1.0,  separator, last);
       });
 
       g.restore();

package/src/utils/convert.ts

@@ -16,26 +16,22 @@ export function convert(col: DG.Column): void {
     NOTATION.SEPARATOR,
     NOTATION.HELM
   ];
-  const filtered = notations.filter((e) => e !== current);
-  const targetNotationInput = ui.choiceInput('Convert to', filtered[0], filtered);
+  const separatorArray = ['-', '.', '/'];
+  const filteredNotations = notations.filter((e) => e !== current);
+  const targetNotationInput = ui.choiceInput('Convert to', filteredNotations[0], filteredNotations);
 
-  const separatorInput = ui.choiceInput('separator', '-', ['-', '.', '/']);
+  const separatorInput = ui.choiceInput('Choose separator', separatorArray[0], separatorArray);
 
-  ui.dialog('Convert sequence')
+  ui.dialog('Convert sequence notation')
     .add(ui.div([
-      ui.h1('current notation'),
-      ui.div(current),
-      targetNotationInput.root
-    ]))
-    .add(ui.div([
-      ui.h1('Separator'),
-      separatorInput,
-
+      ui.h1('Current notation: ' + current),
+      targetNotationInput.root,
+      // TODO: conditional separator input
+      separatorInput.root
     ]))
     .onOK(() => {
       //TODO: create new converted column
-      //const targetNotation: NOTATION = strToEnum<NOTATION>(NOTATION, targetNotationInput.value)!;
-      const targetNotation: NOTATION = targetNotationInput.value as NOTATION;
+      const targetNotation = targetNotationInput.value as NOTATION;
       const separator = separatorInput.value!;
       const newColumn = converter.convert(targetNotation, separator);
       col.dataFrame.columns.add(newColumn);

package/src/utils/multiple-sequence-alignment.ts

@@ -4,7 +4,6 @@ import * as DG from 'datagrok-api/dg';
 import Aioli from '@biowasm/aioli';
 
 import {AlignedSequenceEncoder} from '@datagrok-libraries/bio/src/sequence-encoder';
-import * as C from './constants';
 
 /**
  * Converts array of sequences into simple fasta string.