@datagrok/bio 1.5.7 → 1.5.8

package/src/utils/chem-palette.ts

@@ -0,0 +1,280 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
+import {MonomerLibrary} from '../monomer-library';
+
+
+export class ChemPalette {
+  cp: StringDictionary = {};
+  isInit: boolean = false;
+  monomerLib: MonomerLibrary | null = null;
+
+  /**
+   * Creates an instance of ChemPalette.
+   *
+   * @param {string} scheme Color scheme to use.
+   * @param {boolean} [grouping=false] Is grouping enabled.
+   * @memberof ChemPalette
+   */
+  private constructor(scheme: string, grouping = false) {
+    if (scheme == 'grok')
+      this.cp = ChemPalette.getDatagrok(grouping);
+  }
+
+  /**
+   * Renders 2D representation of a amino acid residue in a tooltip.
+   *
+   * @param {DG.GridCell} cell Grid cell to show tooltip over.
+   * @param {number} x x coordinate of the mouse pointer.
+   * @param {number} y y coordinate of the mouse pointer.
+   * @param {MonomerLibrary} monomerLib Monomer Library instance
+   */
+  static showTooltip(cell: DG.GridCell, x: number, y: number, monomerLib: MonomerLibrary): void {
+    const s = cell.cell.value as string;
+    let toDisplay = [ui.divText(s)];
+    const [, aarOuter, aarInner] = ChemPalette.getColorAAPivot(s);
+    for (const aar of [aarOuter, aarInner]) {
+      if (monomerLib.monomerNames.includes(aar)) {
+        if (aar in ChemPalette.AANames)
+          toDisplay = [ui.divText(ChemPalette.AANames[aar])];
+
+        if (aar in ChemPalette.AAFullNames)
+          toDisplay = [ui.divText(ChemPalette.AANames[ChemPalette.AAFullNames[aar]])];
+
+        const options = {
+          autoCrop: true,
+          autoCropMargin: 0,
+          suppressChiralText: true,
+        };
+        const sketch = grok.chem.svgMol(monomerLib.getMonomerMol(aar), undefined, undefined, options);
+        if (toDisplay.length == 2)
+          toDisplay.push(ui.divText('Modified'));
+
+        toDisplay.push(sketch);
+      }
+    }
+    ui.tooltip.show(ui.divV(toDisplay), x, y);
+  }
+
+  /**
+   * Retursn divided amino with its content in the bracket, if the conetent is number, then its omitted
+   *
+   * @param {string} c raw amino
+   * @return {[string, string]} outer and inner content
+   */
+  static getInnerOuter(c: string): [string, string] {
+    let isInner = 0;
+    let inner = '';
+    let outer = '';
+
+    for (const char of c) {
+      if (char == '(')
+        isInner++;
+      else if (char == ')')
+        isInner--;
+      else if (isInner)
+        inner += char;
+      else
+        outer += char;
+    }
+
+    return !isNaN(parseInt(inner)) ? [outer, ''] : [outer, inner];
+  }
+
+  static getColorAAPivot(monomer: string = '', scheme: 'grok' = 'grok'): [string, string, string, number] {
+    const chemPaletteInstance = ChemPalette.getPalette(scheme);
+    let [outerMonomer, innerMonomer] = ChemPalette.getInnerOuter(monomer);
+    outerMonomer = (outerMonomer.length > 6 ? `${outerMonomer.slice(0, 3)}...` : outerMonomer);
+    innerMonomer = (innerMonomer.length > 6 ? `${innerMonomer.slice(0, 3)}...` : innerMonomer);
+
+    if (monomer.length == 1 || monomer[1] == '(') {
+      const amino = monomer[0]?.toUpperCase()!;
+      return amino in chemPaletteInstance ?
+        [chemPaletteInstance[amino], amino, innerMonomer, 1]:
+        [ChemPalette.undefinedColor, outerMonomer, innerMonomer, 1];
+    }
+
+    if (monomer[0] == 'd' && monomer[1]! in chemPaletteInstance) {
+      if (monomer.length == 2 || monomer[2] == '(') {
+        const amino = monomer[1]?.toUpperCase()!;
+        return amino in chemPaletteInstance ?
+          [chemPaletteInstance[amino], amino, innerMonomer, 2]:
+          [ChemPalette.undefinedColor, outerMonomer, innerMonomer, 2];
+      }
+    }
+
+    if (monomer.substring(0, 3) in ChemPalette.AAFullNames) {
+      if (monomer.length == 3 || monomer[3] == '(') {
+        const amino = ChemPalette.AAFullNames[monomer.substring(0, 3)];
+        return amino in chemPaletteInstance ?
+          [chemPaletteInstance[amino], amino, innerMonomer, 3]:
+          [ChemPalette.undefinedColor, outerMonomer, innerMonomer, 3];
+      }
+    }
+
+    if (monomer[0]?.toLowerCase() == monomer[0]) {
+      if (monomer.substring(1, 3) in ChemPalette.AAFullNames) {
+        if (monomer.length == 4 || monomer[4] == '(') {
+          const amino = ChemPalette.AAFullNames[monomer.substring(1, 3)];
+          return amino in chemPaletteInstance ?
+            [chemPaletteInstance[amino], amino, innerMonomer, 4]:
+            [ChemPalette.undefinedColor, outerMonomer, innerMonomer, 4];
+        }
+      }
+    }
+
+    return [ChemPalette.undefinedColor, outerMonomer, innerMonomer, 0];
+  }
+
+  static colourPalette: {[key: string]: string[]} = {
+    'orange': ['rgb(255,187,120)', 'rgb(245,167,100)', 'rgb(235,137,70)', 'rgb(205, 111, 71)'],
+    'all_green': ['rgb(44,160,44)', 'rgb(74,160,74)', 'rgb(23,103,57)', 'rgb(30,110,96)', 'rgb(60,131,95)',
+      'rgb(24,110,79)', 'rgb(152,223,138)', 'rgb(182, 223, 138)', 'rgb(152, 193, 138)'],
+    'all_blue': ['rgb(31,119,180)', 'rgb(23,190,207)', 'rgb(122, 102, 189)', 'rgb(158,218,229)', 'rgb(141, 124, 217)',
+      'rgb(31, 120, 150)'],
+    'magenta': ['rgb(162,106,192)', 'rgb(197,165,224)', 'rgb(208,113,218)'],
+    'red': ['rgb(214,39,40)', 'rgb(255,152,150)'],
+    'st_blue': ['rgb(23,190,207)', 'rgb(158,218,229)', 'rgb(31,119,180)'],
+    'dark_blue': ['rgb(31,119,180)', 'rgb(31, 120, 150)'],
+    'light_blue': ['rgb(23,190,207)', 'rgb(158,218,229)', 'rgb(108, 218, 229)', 'rgb(23,190,227)'],
+    'lilac_blue': ['rgb(124,102,211)', 'rgb(149,134,217)', 'rgb(97, 81, 150)'],
+    'dark_green': ['rgb(23,103,57)', 'rgb(30,110,96)', 'rgb(60,131,95)', 'rgb(24,110,79)'],
+    'green': ['rgb(44,160,44)', 'rgb(74,160,74)'],
+    'light_green': ['rgb(152,223,138)', 'rgb(182, 223, 138)', 'rgb(152, 193, 138)'],
+    'st_green': ['rgb(44,160,44)', 'rgb(152,223,138)', 'rgb(39, 174, 96)', 'rgb(74,160,74)'],
+    'pink': ['rgb(247,182,210)'],
+    'brown': ['rgb(140,86,75)', 'rgb(102, 62, 54)'],
+    'gray': ['rgb(127,127,127)', 'rgb(199,199,199)', 'rgb(196,156,148)', 'rgb(222, 222, 180)'],
+    'yellow': ['rgb(188,189,34)'],
+    'white': ['rgb(230,230,230)'],
+  };
+
+  static grokGroups: {[key: string]: string[]} = {
+    'yellow': ['C', 'U'],
+    'red': ['G', 'P'],
+    'all_green': ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'],
+    'light_blue': ['R', 'H', 'K'],
+    'dark_blue': ['D', 'E'],
+    'orange': ['S', 'T', 'N', 'Q'],
+  };
+
+  static undefinedColor = 'rgb(100,100,100)';
+
+  static makePalette(dt: {[key: string]: string[]}, simplified = false, grouping = false): StringDictionary {
+    const palette: { [key: string]: string } = {};
+    const groups = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    let currentGroup = 0;
+    for (const [color, monomers] of Object.entries(dt)) {
+      monomers.forEach((monomer, index) => {
+        palette[grouping ? groups[currentGroup] : monomer] = ChemPalette.colourPalette[color][simplified ? 0 : index];
+      });
+      currentGroup++;
+    }
+    return palette;
+  }
+
+  static AANames: StringDictionary = {
+    'G': 'Glycine',
+    'L': 'Leucine',
+    'Y': 'Tyrosine',
+    'S': 'Serine',
+    'E': 'Glutamic acid',
+    'Q': 'Glutamine',
+    'D': 'Aspartic acid',
+    'N': 'Asparagine',
+    'F': 'Phenylalanine',
+    'A': 'Alanine',
+    'K': 'Lysine',
+    'R': 'Arginine',
+    'H': 'Histidine',
+    'C': 'Cysteine',
+    'V': 'Valine',
+    'P': 'Proline',
+    'W': 'Tryptophan',
+    'I': 'Isoleucine',
+    'M': 'Methionine',
+    'T': 'Threonine',
+  };
+
+  static AASmiles: StringDictionary = {
+    'G': 'NCC(=O)O',
+    'L': 'N[C@H](CC(C)C)C(=O)O',
+    'Y': 'NC(CC1=CC=C(O)C=C1)C(=O)O',
+    'S': 'NC(CO)C(=O)O',
+    'E': 'N[C@@H](CCC(O)=O)C(=O)O',
+    'Q': 'N[C@@H](CCC(N)=O)C(=O)O',
+    'D': 'N[C@@H](CC(O)=O)C(=O)O',
+    'N': 'N[C@@H](CC(N)=O)C(=O)O',
+    'F': 'NC(CC1=CC=CC=C1)C(=O)O',
+    'A': 'N[C@H](C)C(=O)O',
+    'K': 'NC(CCCCN)C(=O)O',
+    'R': 'N[C@H](CCCNC(=N)C)C(=O)O',
+    'H': 'NC(CC1=CN=C[N]1)C(=O)O',
+    'C': 'N[C@@H](CS)C(=O)O',
+    'V': 'NC(C(C)C)C(=O)O',
+    'P': 'N(CCC1)C1C(=O)O',
+    'W': 'N[C@@H](Cc1c2ccccc2n([H])c1)C(=O)O',
+    'I': 'N[C@H]([C@H](C)CC)C(=O)O',
+    'M': 'NC(CCSC)C(=O)O',
+    'T': 'NC(C(O)C)C(=O)O',
+  };
+
+  static AASmilesTruncated: StringDictionary = {
+    'G': '*C*',
+    'L': 'CC(C)C[C@H](*)*',
+    'Y': 'C1=CC(=CC=C1CC(*)*)O',
+    'S': 'OCC(*)C*',
+    'E': '*[C@@H](CCC(O)=O)*',
+    'Q': '*N[C@@H](CCC(N)=O)*',
+    'D': '*[C@@H](CC(O)=O)*',
+    'N': '*[C@@H](CC(N)=O)*',
+    'F': 'C1=CC=C(C=C1)CC(*)*',
+    'A': 'C[C@H](*)*',
+    'K': 'C(CCN)CC(*)*',
+    'R': '*[C@H](CCCNC(=N)C)*',
+    'H': 'C1=C(NC=N1)CC(*)*',
+    'C': 'C([C@@H](*)*)S',
+    'V': 'CC(C)C(*)*',
+    'P': 'C1CCN(*)C1*',
+    'W': '*[C@@H](Cc1c2ccccc2n([H])c1)*',
+    'I': 'CC[C@H](C)[C@H](*)*',
+    'M': 'CSCCC(*)*',
+    'T': 'CC(O)C(*)*',
+  };
+
+  static AAFullNames: StringDictionary = {
+    'Ala': 'A',
+    'Arg': 'R',
+    'Asn': 'N',
+    'Asp': 'D',
+    'Cys': 'C',
+    'Gln': 'Q',
+    'Glu': 'E',
+    'Gly': 'G',
+    'His': 'H',
+    'Ile': 'I',
+    'Leu': 'L',
+    'Lys': 'K',
+    'Met': 'M',
+    'Phe': 'F',
+    'Pro': 'P',
+    'Ser': 'S',
+    'Thr': 'T',
+    'Trp': 'W',
+    'Tyr': 'Y',
+    'Val': 'V',
+  };
+
+  static getDatagrok(grouping = false): StringDictionary {
+    return ChemPalette.makePalette(ChemPalette.grokGroups, false, grouping);
+  }
+
+  static getPalette(scheme: 'grok'): StringDictionary {
+    if (scheme == 'grok')
+      return ChemPalette.getDatagrok();
+    else
+      throw new Error(`ChemPalette: scheme \`${scheme}\` does not exist`);
+  }
+}

package/src/utils/convert.ts

@@ -1,6 +1,6 @@
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
-import {NotationConverter} from './notation-converter';
+import {NotationConverter, NOTATION} from './notation-converter';
 
 /**
  * Converts notations of a Macromolecule column
@@ -8,27 +8,36 @@ import {NotationConverter} from './notation-converter';
  * @param {DG.column} col Column with 'Macromolecule' semantic type
  */
 export function convert(col: DG.Column): void {
-  const current = col.tags[DG.TAGS.UNITS];
+  const converter = new NotationConverter(col);
+  const current: NOTATION = converter.sourceNotation;
   //TODO: read all notations
-  const units = [
-    'fasta',
-    'separator',
-    'HELM'
+  const notations = [
+    NOTATION.FASTA,
+    NOTATION.SEPARATOR,
+    NOTATION.HELM
   ];
-  const choices = ui.choiceInput('convert to', '', units.filter((e) => e !== current));
+  const filtered = notations.filter((e) => e !== current);
+  const targetNotationInput = ui.choiceInput('Convert to', filtered[0], filtered);
+
+  const separatorInput = ui.choiceInput('separator', '-', ['-', '.', '/']);
 
   ui.dialog('Convert sequence')
-    .add(
-      ui.div([
-        ui.h1('current notation'),
-        ui.div(current),
-        choices.root
-      ])
-    )
+    .add(ui.div([
+      ui.h1('current notation'),
+      ui.div(current),
+      targetNotationInput.root
+    ]))
+    .add(ui.div([
+      ui.h1('Separator'),
+      separatorInput,
+
+    ]))
     .onOK(() => {
       //TODO: create new converted column
-      const converter = new NotationConverter(col, choices.value!);
-      const newColumn = converter.convert();
+      //const targetNotation: NOTATION = strToEnum<NOTATION>(NOTATION, targetNotationInput.value)!;
+      const targetNotation: NOTATION = targetNotationInput.value as NOTATION;
+      const separator = separatorInput.value!;
+      const newColumn = converter.convert(targetNotation, separator);
       col.dataFrame.columns.add(newColumn);
     })
     .show();

package/src/utils/misc.ts

@@ -0,0 +1,29 @@
+import * as DG from 'datagrok-api/dg';
+
+import * as C from './constants';
+
+export function stringToBool(str: string): boolean {
+  return str === 'true' ? true : false;
+}
+
+export function getSeparator(col: DG.Column<string>): string {
+  const separator = col.tags[C.TAGS.SEPARATOR];
+  if (separator)
+    return separator as string;
+
+  const defaultSeparators = ['.', '-', ' '];
+  const categories = col.categories;
+  const catLen = categories.length;
+  for (const potentialSeparator of defaultSeparators) {
+    if (categories.filter((sequence) => sequence.includes(potentialSeparator)).length == catLen)
+      return potentialSeparator;
+  }
+  return separator as string ?? '';
+}
+
+export function getTypedArrayConstructor(
+  maxNum: number): Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor {
+  return maxNum < 256 ? Uint8Array :
+    maxNum < 65536 ? Uint16Array :
+      Uint32Array;
+}

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

@@ -62,7 +62,7 @@ export async function runKalign(srcCol: DG.Column, isAligned = false): Promise<D
   const tgtUnits = srcUnits.split(':').map((p, i) => i == 1 ? p + '.MSA' : p).join(':');
 
   tgtCol.setTag(DG.TAGS.UNITS, tgtUnits);
-  tgtCol.semType = C.SEM_TYPES.Macro_Molecule;
+  tgtCol.semType = DG.SEMTYPE.MACROMOLECULE;
   return tgtCol;
 }
 

package/src/utils/notation-converter.ts

@@ -1,131 +1,167 @@
 import * as DG from 'datagrok-api/dg';
+import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
 
-// export const enum NOTATION {
-//   // these values can be changed to "user-friendly" ones later on
-//   FASTA = 'fasta',
-//   SEPARATOR = 'separator',
-//   HELM = 'helm'
-// }
+/** enum type to simplify setting "user-friendly" notation if necessary */
+export const enum NOTATION {
+  FASTA = 'fasta',
+  SEPARATOR = 'separator',
+  HELM = 'helm'
+}
 
+/** Class for handling conversion of notation systems in Macromolecule columns */
 export class NotationConverter {
   private _sourceColumn: DG.Column; // the column to be converted
-  private _currentUnits: string; // units of the form fasta:SEQ:NT, etc.
-  private _sourceNotation: string; // current notation (without :SEQ:NT, etc.)
-  private _targetNotation: string;
+  private _sourceUnits: string; // units, of the form fasta:SEQ:NT, etc.
+  private _sourceNotation: NOTATION; // current notation (without :SEQ:NT, etc.)
+
+  private get sourceUnits(): string { return this._sourceUnits; }
 
   private get sourceColumn(): DG.Column { return this._sourceColumn; }
-  private get currentUnits(): string { return this._currentUnits; }
-  private get sourceNotation(): string { return this._sourceNotation; }
-  private get targetNotation(): string { return this._targetNotation; }
-
-  // these values can be changed to "user-friendly" ones later on
-  private _fasta = 'fasta';
-  private _separator = 'separator';
-  private _helm = 'helm';
-
-  public isFasta(): boolean { return this.sourceNotation == this._fasta; }
-  public isSeparator(): boolean { return this.sourceNotation == this._separator; }
-  public isHelm(): boolean { return this.sourceNotation == this._helm; }
-
-  private determineSourceNotation() : string {
-    if (this.currentUnits.toLowerCase().startsWith('fasta'))
-      return 'fasta';
-    else if (this.currentUnits.toLowerCase().startsWith('separator'))
-      return 'separator';
+
+  public get sourceNotation(): NOTATION { return this._sourceNotation; }
+
+  public isFasta(): boolean { return this.sourceNotation === NOTATION.FASTA; }
+
+  public isSeparator(): boolean { return this.sourceNotation === NOTATION.SEPARATOR; }
+
+  public isHelm(): boolean { return this.sourceNotation === NOTATION.HELM; }
+
+  public toFasta(targetNotation: NOTATION): boolean { return targetNotation === NOTATION.FASTA; }
+
+  public toSeparator(targetNotation: NOTATION): boolean { return targetNotation === NOTATION.SEPARATOR; }
+
+  public toHelm(targetNotation: NOTATION): boolean { return targetNotation === NOTATION.HELM; }
+
+  // TODO: isRna
+  public isRna(): boolean { return this.sourceUnits.toLowerCase().endsWith('nt'); }
+
+  public isPeptide(): boolean { return this.sourceUnits.toLowerCase().endsWith('pt'); }
+
+  /** Associate notation types with the corresponding units */
+  /**
+   * @return {NOTATION} notation associated with the units type
+   */
+  private determineSourceNotation(): NOTATION {
+    if (this.sourceUnits.toLowerCase().startsWith('fasta'))
+      return NOTATION.FASTA;
+    else if (this.sourceUnits.toLowerCase().startsWith('separator'))
+      return NOTATION.SEPARATOR;
     else
       // TODO: handle possible exceptions
-      return 'HELM';
+      return NOTATION.HELM;
   }
 
-  private convertFastaToSeparator(): DG.Column {
-    // TODO: implementation
-    const len = this.sourceColumn.length;
-    const newColName = 'converted';
-    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('fasta2sep'));
+  // TODO: write doc
+  private getNewColumn(targetNotation: NOTATION): DG.Column {
+    const col = this.sourceColumn;
+    const len = col.length;
+    const name = targetNotation + '(' + col.name + ')';
+    const newColName = col.dataFrame.columns.getUnusedName(name);
+    // dummy code
+    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill(''));
     newColumn.semType = 'Macromolecule';
+    const newUnits = this.sourceUnits.replace(this.sourceNotation.toString(), targetNotation.toString());
+    newColumn.setTag(DG.TAGS.UNITS, newUnits);
+    // TODO: determine all the qualifiers (units, ...), perhaps, using detectors
     return newColumn;
   }
 
-  private convertFastaToHelm(): DG.Column {
+  // TODO: write doc
+  private convertFastaToSeparator(separator: string): DG.Column {
     // TODO: implementation
-    const len = this.sourceColumn.length;
-    const newColName = 'converted';
-    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('fasta2helm'));
-    newColumn.semType = 'Macromolecule';
+    // * specify separator
+    // * fasta gap symbol should NOT be considered '-' only, but set as a parameter
+    // * in fasta every position is a monomer (no multi-char monomers), call splitToMonomers() method
+    // * in the resulting jagged array, every gap symbol is to be replaced by
+    // the empty string, while the monomers, to be separated by the separator
+    // (specified as a parameter)
+    // On splitToMonomers(): /libraries/bio/src/viewers/WebLogo --> getSplitter
+
+    const gapSymbol = '-'; // to be specified as an argument
+    const splitterAsFasta = WebLogo.splitterAsFasta;
+    const newColumn = this.getNewColumn(NOTATION.SEPARATOR);
+    newColumn.init((idx: number) => {
+      const sourcePolymer = this.sourceColumn.get(idx);
+      const monomersArray = splitterAsFasta(sourcePolymer);
+      for (let i = 0; i < monomersArray.length; i++) {
+        if (monomersArray[i] === gapSymbol)
+          monomersArray[i] = '';
+      }
+      return monomersArray.join(separator);
+    });
+    return newColumn;
+  }
+
+  private wrapRnaNucleotideToHelm(monomer: string) {
+
+  }
+
+  private convertFastaToHelm(): DG.Column {
+    const gapSymbol = '-'; // to be specified as an argument
+    const splitterAsFasta = WebLogo.splitterAsFasta;
+    const newColumn = this.getNewColumn(NOTATION.HELM);
+    newColumn.init((idx: number) => {
+      const sourcePolymer = this.sourceColumn.get(idx);
+      const monomersArray = splitterAsFasta(sourcePolymer);
+      for (let i = 0; i < monomersArray.length; i++) {
+        // // TODO: handle gap symbols -- replace by asterisk
+        // if (monomersArray[i] === gapSymbol)
+        //   monomersArray[i] = '*';
+        // else
+      }
+      // TODO: determine conditionally (if isDna(), or isRna(), or isPeptide()) the template
+      return monomersArray.join('');
+    });
     return newColumn;
   }
 
   private convertSeparatorToFasta(): DG.Column {
     // TODO: implementation
-    const len = this.sourceColumn.length;
-    const newColName = 'converted';
-    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('sep2fasta'));
-    newColumn.semType = 'Macromolecule';
-    return newColumn;
+    // * similarly to fasta2separator, divide string into monomers
+    // * adjacent separators is a gap (symbol to be specified)
+    // * the monomers MUST be single-character onles, otherwise forbid
+    // conversion
+    //getSplitterWithSeparator
+    return this.getNewColumn(NOTATION.FASTA);
   }
 
   private convertSeparatorToHelm(): DG.Column {
     // TODO: implementation
-    const len = this.sourceColumn.length;
-    const newColName = 'converted';
-    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('sep2helm'));
-    newColumn.semType = 'Macromolecule';
-    return newColumn;
+    return this.getNewColumn(NOTATION.HELM);
   }
 
   private convertHelmToFasta(): DG.Column {
     // TODO: implementation
-    const len = this.sourceColumn.length;
-    const newColName = 'converted';
-    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('helm2fasta'));
-    newColumn.semType = 'Macromolecule';
-    return newColumn;
+    return this.getNewColumn(NOTATION.FASTA);
   }
 
   private convertHelmToSeparator(): DG.Column {
-    // TODO: implementation
-    const len = this.sourceColumn.length;
-    const newColName = 'converted';
-    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('helm2sep'));
-    newColumn.semType = 'Macromolecule';
-    return newColumn;
+    // TODO: implementatioreturn this.getNewColumn();
+    return this.getNewColumn(NOTATION.SEPARATOR);
   }
 
+  /** Dispatcher method for notation conversion */
   // TODO: write the bodies of converter methods
-  public convert() : DG.Column {
-    if (
-      this.sourceNotation == this._fasta &&
-      this.targetNotation == this._separator
-    )
-      return this.convertFastaToSeparator();
-    else if (
-      this.sourceNotation == this._fasta &&
-      this.targetNotation == this._helm
-    )
+  public convert(targetNotation: NOTATION, separator: string | null): DG.Column {
+    if (this.sourceNotation === targetNotation)
+      throw new Error('Target notation is not specified');
+    if (this.isFasta() && this.toSeparator(targetNotation))
+      return this.convertFastaToSeparator(separator!); // there is the only place where a separator is needed
+    else if (this.isFasta() && this.toHelm(targetNotation))
       return this.convertFastaToHelm();
-    else if (
-      this.sourceNotation == this._separator &&
-      this.targetNotation == this._fasta
-    )
+    else if (this.isSeparator() && this.toFasta(targetNotation))
       return this.convertSeparatorToFasta();
-    else if (
-      this.sourceNotation == this._separator &&
-      this.targetNotation == this._helm
-    )
+    else if (this.isSeparator() && this.toHelm(targetNotation))
       return this.convertSeparatorToHelm();
-    else if (
-      this.sourceNotation == this._helm &&
-      this.targetNotation == this._fasta
-    )
+    else if (this.isHelm() && this.toFasta(targetNotation))
       return this.convertHelmToFasta();
     else
       return this.convertHelmToSeparator();
   }
 
-  public constructor(col: DG.Column, target: string) {
+  public constructor(col: DG.Column) {
     this._sourceColumn = col;
-    this._currentUnits = this._sourceColumn.tags[DG.TAGS.UNITS];
+    this._sourceUnits = this._sourceColumn.tags[DG.TAGS.UNITS];
     this._sourceNotation = this.determineSourceNotation();
-    this._targetNotation = target;
   }
 }

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

@@ -2,9 +2,9 @@ import {IDrawTooltipParams} from '@datagrok-libraries/ml/src/viewers/activity-cl
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 import {getSimilarityFromDistance} from '@datagrok-libraries/utils/src/similarity-metrics';
-import { AvailableMetrics } from '@datagrok-libraries/ml/src/typed-metrics';
+import {AvailableMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 
-export async function sequenceGetSimilarities(col: DG.Column, seq: string): Promise<DG.Column | null>{ 
+export async function sequenceGetSimilarities(col: DG.Column, seq: string): Promise<DG.Column | null> {
   const stringArray = col.toList();
   const distances = new Array(stringArray.length).fill(0.0);
   for (let i = 0; i < stringArray.length; ++i)

package/src/utils/types.ts

@@ -0,0 +1,13 @@
+import * as DG from 'datagrok-api/dg';
+
+export type DataFrameDict = {[key: string]: DG.DataFrame};
+
+export namespace BarChart {
+  export type BarPart = {colName : string, aaName : string};
+  export type BarStatsObject = {name: string, count: number, selectedCount: number};
+}
+
+export type UTypedArray = Uint8Array | Uint16Array | Uint32Array;
+//AAR: (Position: (index: indexList))
+export type SubstitutionsInfo = Map<string, Map<string, Map<number, number[] | UTypedArray>>>;
+export type SelectionObject = {[postiton: string]: string[]};