@datagrok/bio 1.5.8 → 1.6.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "@datagrok/bio",
   "beta": false,
   "friendlyName": "Bio",
-  "version": "1.5.8",
+  "version": "1.6.0",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -11,7 +11,7 @@
   },
   "dependencies": {
     "@biowasm/aioli": ">=2.4.0",
-    "@datagrok-libraries/bio": "^2.4.1",
+    "@datagrok-libraries/bio": "^2.5.0",
     "@datagrok-libraries/utils": "^1.0.0",
     "@datagrok-libraries/ml": "^2.0.9",
     "cash-dom": "latest",

package/src/package-test.ts

@@ -10,6 +10,7 @@ import './tests/sequence-space-test';
 import './tests/activity-cliffs-tests';
 import './tests/splitter-test';
 import './tests/renderer-test';
+import './tests/convert-test';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -19,6 +19,8 @@ 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';
 
 //tags: init
 export async function initBio(): Promise<void> {
@@ -38,6 +40,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 +98,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 +138,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,11 +164,18 @@ 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> {
+//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;
+
   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);
@@ -152,7 +190,10 @@ export async function toAtomicLevel(df: DG.DataFrame, sequence: DG.Column): Prom
 //input: dataframe table
 //input: column sequence { semType: Macromolecule }
 //output: column result
-export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.Column): Promise<DG.Column> {
+export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.Column): Promise<DG.Column | null> {
+  if (!checkInputColumn(col, 'MSA', ['fasta'], ['DNA', 'RNA', 'PT']))
+    return null;
+
   const msaCol = await runKalign(col, false);
   table.columns.add(msaCol);
 
@@ -171,19 +212,24 @@ export async function compositionAnalysis(): Promise<void> {
   // Higher priority for columns with MSA data to show with WebLogo.
   const tv = grok.shell.tv;
   const df = tv.dataFrame;
-  const semTypeColList = df.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
-  let col: DG.Column | undefined = semTypeColList.find((col) => {
-    const units = col.getTag(DG.TAGS.UNITS);
-    return units ? units.indexOf('MSA') !== -1 : false;
-  });
-  if (!col)
-    col = semTypeColList[0];
 
+  const col: DG.Column | null = WebLogo.pickUpSeqCol2(df);
   if (!col) {
     grok.shell.error('Current table does not contain sequences');
     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()))) {
+    grok.shell.warning('Composition analysis is allowed for ' +
+      `notation${allowedNotations.length > 1 ? 's' : ''} ${allowedNotations.map((n) => `"${n}"`).join(', ')}.`);
+    return;
+  }
+
   tv.addViewer('WebLogo', {sequenceColumnName: col.name});
 }
 
@@ -201,7 +247,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 [] {
@@ -221,13 +267,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

@@ -44,7 +44,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 +59,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
@@ -90,10 +90,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;
     };
   };
@@ -127,7 +127,7 @@ 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('testSeparatorPtToFasta', async () => {
@@ -136,15 +136,15 @@ RNA1{R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P}$$$
   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);

package/src/tests/detectors-test.ts

@@ -105,9 +105,12 @@ MWRSWY-CKHP
     fastaCsv = 'fastaCsv',
     fastaFasta = 'fastaFasta',
     msaComplex = 'msaComplex',
-    idCsv = 'idCsv',
-    sarSmallCsv = 'sarSmallCsv',
     helmCsv = 'helmCsv',
+    testDemogCsv = 'testDemogCsv',
+    testHelmCsv = 'testHelmCsv',
+    testIdCsv = 'testIdCsv',
+    testSmilesCsv = 'testSmilesCsv',
+    testSmiles2Csv = 'testSmiles2Csv',
   }
 
   const samples: { [key: string]: string } = {
@@ -115,9 +118,12 @@ MWRSWY-CKHP
     'fastaCsv': 'System:AppData/Bio/samples/sample_FASTA.csv',
     'fastaFasta': 'System:AppData/Bio/samples/sample_FASTA.fasta',
     'msaComplex': 'System:AppData/Bio/samples/sample_MSA.csv',
-    'idCsv': 'System:AppData/Bio/samples/id.csv',
-    'sarSmallCsv': 'System:AppData/Bio/samples/sar-small.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',
   };
 
   const _samplesDfs: { [key: string]: Promise<DG.DataFrame> } = {};
@@ -238,11 +244,11 @@ MWRSWY-CKHP
   });
 
   test('samplesIdCsvNegativeID', async () => {
-    await _testNeg(readSamples(Samples.idCsv), 'ID');
+    await _testNeg(readSamples(Samples.testIdCsv), 'ID');
   });
 
   test('samplesSarSmallCsvNegativeSmiles', async () => {
-    await _testNeg(readSamples(Samples.sarSmallCsv), 'smiles');
+    await _testNeg(readSamples(Samples.testSmilesCsv), 'smiles');
   });
 
   test('samplesHelmCsvHELM', async () => {
@@ -252,6 +258,42 @@ MWRSWY-CKHP
   test('samplesHelmCsvNegativeActivity', async () => {
     await _testNeg(readSamples(Samples.helmCsv), 'Activity');
   });
+
+  // sample_testHelm.csb
+  // columns: ID,Test type,HELM string,Valid?,Mol Weight,Mol Formula,SMILES
+  test('samplesTestHelmNegativeID', async () => {
+    await _testNeg(readSamples(Samples.testHelmCsv), 'ID');
+  });
+  test('samplesTestHelmNegativeTestType', async () => {
+    await _testNeg(readSamples(Samples.testHelmCsv), 'Test type');
+  });
+  test('samplesTestHelmPositiveHelmString', async () => {
+    await _testPos(readSamples(Samples.testHelmCsv), 'HELM string', 'HELM');
+  });
+  test('samplesTestHelmNegativeValid', async () => {
+    await _testNeg(readSamples(Samples.testHelmCsv), 'Valid?');
+  });
+  test('samplesTestHelmNegativeMolWeight', async () => {
+    await _testNeg(readSamples(Samples.testHelmCsv), 'Mol Weight');
+  });
+  test('samplesTestHelmNegativeMolFormula', async () => {
+    await _testNeg(readSamples(Samples.testHelmCsv), 'Mol Formula');
+  });
+  test('samplesTestHelmNegativeSmiles', async () => {
+    await _testNeg(readSamples(Samples.testHelmCsv), 'Smiles');
+  });
+
+  test('samplesTestDemogNegativeAll', async () => {
+    const dfFunc: DfReaderFunc = readSamples(Samples.testDemogCsv);
+    const df: DG.DataFrame = await dfFunc();
+
+    for (const col of df.columns.toList())
+      await _testNeg(dfFunc, col.name);
+  });
+
+  test('samplesTestSmiles2NegativeSmiles', async () => {
+    await _testNeg(readSamples(Samples.testSmiles2Csv), 'SMILES');
+  });
 });
 
 export async function _testNeg(readDf: DfReaderFunc, colName: string) {

package/src/tests/renderer-test.ts

@@ -6,31 +6,53 @@ import * as DG from 'datagrok-api/dg';
 import {importFasta, multipleSequenceAlignmentAny} from '../package';
 
 category('renderers', () => {
+  let tvList: DG.TableView[];
+
+  before(async () => {
+    tvList = [];
+  });
+
+  after(async () => {
+    tvList.forEach((tv: DG.TableView) => tv.close());
+  });
+
   test('afterMsa', async () => {
     await _testAfterMsa();
   });
-});
 
-export async function _testAfterMsa() {
-  const fastaTxt: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.fasta');
-  const df: DG.DataFrame = importFasta(fastaTxt)[0];
+  async function _testAfterMsa() {
+    const fastaTxt: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.fasta');
+    const df: DG.DataFrame = importFasta(fastaTxt)[0];
+
+    const srcSeqCol: DG.Column | null = df.col('sequence');
+    expect(srcSeqCol !== null, true);
+    console.log('Bio: tests/renderers/afterMsa, src data loaded');
 
-  const seqCol: DG.Column | null = df.col('sequence');
-  expect(seqCol !== null, true);
+    const tv: DG.TableView = grok.shell.addTableView(df);
+    console.log('Bio: tests/renderers/afterMsa, table view');
 
-  const tv: DG.TableView = grok.shell.addTableView(df);
-  await grok.data.detectSemanticTypes(df);
+    await grok.data.detectSemanticTypes(df);
+    console.log('Bio: tests/renderers/afterMsa, detectSemanticTypes');
 
-  expect(seqCol!.semType, DG.SEMTYPE.MACROMOLECULE);
-  expect(seqCol!.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
-  expect(seqCol!.getTag('cell.renderer'), 'Macromolecule');
+    console.log('Bio: tests/renderers/afterMsa, src before test semType' +
+      `semType="${srcSeqCol!.semType}", units="${srcSeqCol!.getTag(DG.TAGS.UNITS)}", ` +
+      `cell.renderer="${srcSeqCol!.getTag('cell.renderer')}"`);
+    expect(srcSeqCol!.semType, DG.SEMTYPE.MACROMOLECULE);
+    expect(srcSeqCol!.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
+    expect(srcSeqCol!.getTag('cell.renderer'), 'Macromolecule');
+    console.log('Bio: tests/renderers/afterMsa, src semType tested');
 
-  const seqMsaCol: DG.Column = await multipleSequenceAlignmentAny(df, seqCol!);
-  tv.grid.invalidate();
+    const msaSeqCol: DG.Column | null = await multipleSequenceAlignmentAny(df, srcSeqCol!);
+    console.log('Bio: tests/renderers/afterMsa, msaSeqCol created');
 
-  expect(seqMsaCol!.semType, DG.SEMTYPE.MACROMOLECULE);
-  expect(seqMsaCol!.getTag(DG.TAGS.UNITS), 'fasta:SEQ.MSA:PT');
-  expect(seqMsaCol!.getTag('cell.renderer'), 'Macromolecule');
+    tv.grid.invalidate();
+    console.log('Bio: tests/renderers/afterMsa, tv.grid invalidated');
 
-  // tv.close();
-}
+    expect(msaSeqCol!.semType, DG.SEMTYPE.MACROMOLECULE);
+    expect(msaSeqCol!.getTag(DG.TAGS.UNITS), 'fasta:SEQ.MSA:PT');
+    expect(msaSeqCol!.getTag('cell.renderer'), 'Macromolecule');
+    console.log('Bio: tests/renderers/afterMsa, msa semType tested');
+
+    tvList.push(tv);
+  }
+});

package/src/utils/cell-renderer.ts

@@ -1,6 +1,4 @@
 import * as C from "./constants";
-import {getSeparator} from "./misc";
-import {ChemPalette} from "./chem-palette";
 import * as DG from 'datagrok-api/dg';
 import {AminoacidsPalettes} from "@datagrok-libraries/bio/src/aminoacids";
 import {NucleotidesPalettes} from "@datagrok-libraries/bio/src/nucleotides";
@@ -9,7 +7,8 @@ import {SplitterFunc, WebLogo} from "@datagrok-libraries/bio/src/viewers/web-log
 import {SeqPalette} from "@datagrok-libraries/bio/src/seq-palettes";
 import * as ui from 'datagrok-api/ui';
 
-const lru = new DG.LruCache<any, any>(); 
+const lru = new DG.LruCache<any, any>();
+const undefinedColor =  'rgb(100,100,100)';
 
 function getPalleteByType(paletteType: string): SeqPalette  {
   switch (paletteType) {
@@ -48,7 +47,7 @@ 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.
@@ -57,12 +56,15 @@ export function processSequence(subParts: string[]): [string[], boolean] {
  */
 function printLeftOrCentered(
     x: number, y: number, w: number, h: number,
-    g: CanvasRenderingContext2D, s: string, color = ChemPalette.undefinedColor,
+    g: CanvasRenderingContext2D, s: string, color = undefinedColor,
     pivot: number = 0, left = false, hideMod = false, transparencyRate: number = 1.0,
-    separator: string = ''): number {
+    separator: string = '', last:boolean = false): number {
   g.textAlign = 'start';
   let colorPart = s.substring(0);
   let grayPart = separator;
+  if (last) {
+    grayPart = '';
+  }
   const textSize = g.measureText(colorPart + grayPart);
   const indent = 5;
 
@@ -87,49 +89,8 @@ 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 {
-  constructor() {
-    super();
-  }
 
   get name(): string {return 'macromoleculeSequence';}
 
@@ -162,7 +123,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
       let 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);
@@ -186,28 +147,31 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
       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);
-      console.log(subParts);
-  
+      // 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, false, 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

@@ -50,10 +50,12 @@ export async function runKalign(srcCol: DG.Column, isAligned = false): Promise<D
 
   await CLI.fs.writeFile('input.fa', fasta);
   const output = await CLI.exec('kalign input.fa -f fasta -o result.fasta');
-  const buf = await CLI.cat('result.fasta');
-
   console.warn(output);
 
+  const buf = await CLI.cat('result.fasta');
+  if (!buf)
+    throw new Error(`kalign output no result`);
+
   const aligned = _fastaToStrings(buf).slice(0, sequences.length);
   const tgtCol = DG.Column.fromStrings(`msa(${srcCol.name})`, aligned);