@datagrok/sequence-translator 1.0.14 → 1.0.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "author": {
     "name": "Alexey Choposky",
     "email": "achopovsky@datagrok.ai"
@@ -13,10 +13,10 @@
     "directory": "packages/SequenceTranslator"
   },
   "dependencies": {
-    "@datagrok-libraries/utils": "^1.15.5",
+    "@datagrok-libraries/utils": "^1.17.2",
     "@types/react": "^18.0.15",
     "@datagrok-libraries/bio": "^5.11.1",
-    "datagrok-api": "^1.7.2",
+    "datagrok-api": "^1.8.2",
     "datagrok-tools": "^4.1.2",
     "npm": "^8.11.0",
     "openchemlib": "6.0.1",
@@ -24,25 +24,6 @@
     "ts-loader": "^9.3.1",
     "typescript": "^4.7.4"
   },
-  "scripts": {
-    "link-api": "npm link datagrok-api",
-    "link-all": "npm link datagrok-api @datagrok-libraries/utils @datagrok-libraries/bio",
-    "debug-sequencetranslator": "grok publish",
-    "release-sequencetranslator": "grok publish localhost --release",
-    "build-sequencetranslator": "webpack",
-    "build": "webpack",
-    "debug-sequencetranslator-public": "grok publish public",
-    "release-sequencetranslator-public": "grok publish public --release",
-    "debug-sequencetranslator-local": "grok publish local",
-    "release-sequencetranslator-local": "grok publish local --release",
-    "test": "jest",
-    "test-dev": "set HOST=dev && jest",
-    "test-local": "set HOST=localhost && jest"
-  },
-  "sources": [
-    "css/style.css",
-    "vendors/openchemlib-full.js"
-  ],
   "devDependencies": {
     "@types/jest": "^27.0.0",
     "@types/jquery": "^3.5.14",
@@ -62,5 +43,27 @@
     "@types/node-fetch": "^2.6.2",
     "node-fetch": "^2.6.7"
   },
+  "grokDependencies": {
+    "@datagrok/chem": "1.3.32"
+  },
+  "scripts": {
+    "link-api": "npm link datagrok-api",
+    "link-all": "npm link datagrok-api @datagrok-libraries/utils @datagrok-libraries/bio",
+    "debug-sequencetranslator": "grok publish",
+    "release-sequencetranslator": "grok publish localhost --release",
+    "build-sequencetranslator": "webpack",
+    "build": "webpack",
+    "debug-sequencetranslator-public": "grok publish public",
+    "release-sequencetranslator-public": "grok publish public --release",
+    "debug-sequencetranslator-local": "grok publish local",
+    "release-sequencetranslator-local": "grok publish local --release",
+    "test": "jest",
+    "test-dev": "set HOST=dev && jest",
+    "test-local": "set HOST=localhost && jest"
+  },
+  "sources": [
+    "css/style.css",
+    "vendors/openchemlib-full.js"
+  ],
   "category": "Bioinformatics"
 }

package/scripts/build-monomer-lib.py

@@ -1,10 +1,8 @@
 from io import TextIOWrapper
 
-from rdkit.Chem import AllChem
 from rdkit import Chem
 
 import orjson
-import json
 
 import click
 
@@ -12,16 +10,55 @@ from click_default_group import DefaultGroup
 from rdkit.Chem.rdchem import Mol
 
 
-def smiles2molfile(smiles: str) -> str:
-    mol: Mol = Chem.MolFromSmiles(smiles)
+def molAddCollection(mol: Mol, name: str, title: str = None) -> str:
+    """
+    Get and postprocess (atom's CFG, title, e.t.c.) molblock
+    :param mol:    Mol molecule structure / object
+    :param name:   Monomer name to add to molblock title
+    :param title:  title to replace in Chem.MolToMolBlock() string output
+    :return:       molblock string
+    """
     res: str = Chem.MolToMolBlock(mol, forceV3000=True)  # MolToMolFile
-    return res
 
+    mb_line_list: list[str] = res.split('\n')
+    if title:
+        mb_line_list[1] = title
+
+    if name and name not in mb_line_list[1]:
+        mb_line_list[1] += '|' + name
+
+    end_bond_idx: int = mb_line_list.index('M  V30 END BOND')
+    chirality = [atom.GetChiralTag() for atom in mol.GetAtoms()]
+    begin_atom_idx = mb_line_list.index('M  V30 BEGIN ATOM')
+    end_atom_idx = mb_line_list.index('M  V30 END ATOM')
+    for atom_idx in range(1, end_atom_idx - begin_atom_idx):
+        line_idx = begin_atom_idx + atom_idx
+        atom_ch = chirality[atom_idx - 1]
+        if atom_ch != Chem.rdchem.CHI_UNSPECIFIED:
+            mb_line_list[line_idx] += " CFG={0}".format(int(atom_ch))
+
+    steabs: list[int] = [i + 1 for (i, ch) in enumerate(chirality) if ch != Chem.rdchem.CHI_UNSPECIFIED]
+    if len(steabs) > 0:
+        steabs_str: str = "M  V30 MDLV30/STEABS ATOMS=({count} {list})" \
+            .format(count=len(steabs), list=' '.join([str(idx) for idx in steabs]))
+
+        mb_line_list = mb_line_list[:(end_bond_idx + 1)] + \
+                       ["M  V30 BEGIN COLLECTION", steabs_str, "M  V30 END COLLECTION"] + \
+                       mb_line_list[(end_bond_idx + 1):]
 
-def molV2000toMolV3000(molV2K: str) -> str:
-    mol: str = Chem.MolFromMolBlock(molV2K)
-    res: str = Chem.MolToMolBlock(mol, forceV3000=True)
-    return res.replace('Pol', 'O  ')
+    return '\n'.join(mb_line_list)
+
+
+def molfile2molfile(src_mol: str, name: str) -> str:
+    mol: Mol = Chem.MolFromMolBlock(src_mol)
+    src_mf_lines = src_mol.split('\n')
+    title = src_mf_lines[1]
+    return molAddCollection(mol, name, title=title)
+
+
+def smiles2molfile(smiles: str, name: str) -> str:
+    mol: Mol = Chem.MolFromSmiles(smiles)
+    return molAddCollection(mol, name)
 
 
 CodesType = dict[str, dict[str, list[str]]]
@@ -29,13 +66,13 @@ CodesType = dict[str, dict[str, list[str]]]
 
 class Monomer:
     def __init__(self,
-                 symbol: str, name: str, smiles: str,
+                 symbol: str, name: str, molfile: str, smiles: str,
                  codes: CodesType):
         self.monomerType = 'Backbone'
         self.smiles = smiles
         self.name = name
         self.author = 'SequenceTranslator'
-        self.molfile = smiles2molfile(smiles)
+        self.molfile = molfile2molfile(molfile, name) if molfile else smiles2molfile(smiles, name)
         self.naturalAnalog = ''
         self.rgroups = [
             {
@@ -58,8 +95,9 @@ class Monomer:
 
     @staticmethod
     def from_json(src_json: {}):
-        obj = Monomer(src_json['symbol'], src_json['name'], src_json['smiles'], src_json['codes'])
-        obj.molfile = src_json['molfile']
+        obj = Monomer(src_json['symbol'], src_json['name'],
+                      src_json['molfile'], src_json['smiles'],
+                      src_json['codes'])
         return obj
 
     def to_json(self):
@@ -89,7 +127,7 @@ def codes2monomers(codes_json: {}) -> dict[str, Monomer]:
                     symbol = monomer_json['name']
                     name = monomer_json['name']
                     smiles = monomer_json['SMILES']
-                    monomers_res[monomer_name] = Monomer(symbol, name, smiles, {})
+                    monomers_res[monomer_name] = Monomer(symbol, name, None, smiles, {})
                 codes = monomers_res[monomer_name].codes
                 if codes_src not in codes:
                     codes[codes_src] = {}

package/src/apps/oligo-sd-file-app.ts

@@ -0,0 +1,58 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {_package} from '../package';
+import {FileSource} from 'datagrok-api/dg';
+
+export class OligoSdFileApp {
+  df!: DG.DataFrame;
+
+  constructor() {}
+
+  async init(srcDf?: DG.DataFrame): Promise<void> {
+    let dataDf: DG.DataFrame;
+    if (srcDf) {
+      dataDf = srcDf;
+    } else {
+      const dfFn: string = 'System:AppData/SequenceTranslator/test input_Nov28_Duplex_dimer.xlsx';
+      dataDf = await this.loadData(dfFn);
+    }
+
+    this.setData(dataDf);
+  }
+
+  async loadData(dfFn: string): Promise<DG.DataFrame> {
+    //
+    const dataDf: DG.DataFrame = await grok.data.files.openTable(dfFn);
+    return dataDf;
+  }
+
+  async setData(df: DG.DataFrame): Promise<void> {
+    if (this.viewed) {
+      await this.destroyView();
+      this.viewed = false;
+    }
+
+    this.df = df;
+
+    if (!this.viewed) {
+      await this.buildView();
+      this.viewed = true;
+    }
+  }
+
+  private viewed: boolean = false;
+  private tView?: DG.TableView;
+
+  async destroyView(): Promise<void> {
+    this.tView!.close();
+    delete this.tView;
+  }
+
+  async buildView(): Promise<void> {
+    console.debug('SequenceTranslator: OligoSdFileApp.buildView() ');
+
+    this.tView = grok.shell.addTableView(this.df);
+    this.tView.path = this.tView.basePath = 'func/SequenceTranslator.oligoSdFileApp';
+  }
+}

package/src/autostart/calculations.ts

@@ -1,21 +1,24 @@
 import * as DG from 'datagrok-api/dg';
+
 import {sortByStringLengthInDescendingOrder} from '../helpers';
 import {MODIFICATIONS} from '../structures-works/map';
 
 export function saltMass(
-  saltNames: string[], molWeightCol: DG.Column, equivalentsCol: DG.Column, i: number, saltCol: DG.Column,
+  saltNames: string[], saltsMolWeightList: number[], equivalentsCol: DG.Column, i: number, saltCol: DG.Column
 ): number {
   const saltRowIndex = saltNames.indexOf(saltCol.get(i));
   return (
-    saltRowIndex == -1 || molWeightCol.get(saltRowIndex) == DG.FLOAT_NULL || equivalentsCol.get(i) == DG.INT_NULL
+    saltRowIndex == -1 || saltsMolWeightList[saltRowIndex] == DG.FLOAT_NULL || equivalentsCol.get(i) == DG.INT_NULL
   ) ?
     DG.FLOAT_NULL :
-    molWeightCol.get(saltRowIndex) * equivalentsCol.get(i);
+    saltsMolWeightList[saltRowIndex] * equivalentsCol.get(i);
 }
 
-export function saltMolWeigth(saltNamesList: string[], saltCol: DG.Column, molWeightCol: DG.Column, i: number): number {
+export function saltMolWeigth(
+  saltNamesList: string[], saltCol: DG.Column, saltsMolWeightList: number[], i: number
+): number {
   const saltRowIndex = saltNamesList.indexOf(saltCol.get(i));
-  return (saltRowIndex == -1) ? DG.FLOAT_NULL : molWeightCol.get(saltRowIndex);
+  return (saltRowIndex == -1) ? DG.FLOAT_NULL : saltsMolWeightList[saltRowIndex];
 }
 
 export function batchMolWeight(compoundMolWeightCol: DG.Column, saltMassCol: DG.Column, i: number): number {
@@ -24,7 +27,7 @@ export function batchMolWeight(compoundMolWeightCol: DG.Column, saltMassCol: DG.
     compoundMolWeightCol.get(i) + saltMassCol.get(i);
 }
 
-export function molecularWeight(sequence: string, weightsObj: {[index: string]: number}): number {
+export function molecularWeight(sequence: string, weightsObj: { [index: string]: number }): number {
   const codes = sortByStringLengthInDescendingOrder(Object.keys(weightsObj)).concat(Object.keys(MODIFICATIONS));
   let weight = 0;
   let i = 0;

package/src/autostart/constants.ts

@@ -6,18 +6,6 @@ export const SEQUENCE_TYPES = {
   DIMER: 'Dimer',
 };
 
-export const CELL_STRUCTURE = {
-  DUPLEX: {
-    BEFORE_SS: 'SS ',
-    BEFORE_AS: '\r\nAS ',
-  },
-  TRIPLEX_OR_DIMER: {
-    BEFORE_SS: 'SS ',
-    BEFORE_AS1: '\r\nAS1 ',
-    BEFORE_AS2: '\r\nAS2 ',
-  },
-};
-
 export const COL_NAMES = {
   CHEMISTRY: 'Chemistry',
   NUMBER: 'Number',

package/src/autostart/registration.ts

@@ -1,10 +1,12 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import {siRnaBioSpringToGcrs, siRnaAxolabsToGcrs, gcrsToNucleotides, asoGapmersBioSpringToGcrs, gcrsToMermade12,
-  siRnaNucleotidesToGcrs} from '../structures-works/converters';
+import {
+  siRnaBioSpringToGcrs, siRnaAxolabsToGcrs, gcrsToNucleotides, asoGapmersBioSpringToGcrs, gcrsToMermade12,
+  siRnaNucleotidesToGcrs
+} from '../structures-works/converters';
 import {weightsObj, SYNTHESIZERS} from '../structures-works/map';
-import {SEQUENCE_TYPES, COL_NAMES, GENERATED_COL_NAMES, CELL_STRUCTURE} from './constants';
+import {SEQUENCE_TYPES, COL_NAMES, GENERATED_COL_NAMES} from './constants';
 import {saltMass, saltMolWeigth, molecularWeight, batchMolWeight} from './calculations';
 import {isValidSequence} from '../structures-works/sequence-codes-tools';
 import {sequenceToMolV3000} from '../structures-works/from-monomers';
@@ -17,109 +19,137 @@ import {ICDS} from './ICDs';
 import {SOURCES} from './sources';
 import {IDPS} from './IDPs';
 
+import {sdfAddColumns} from '../utils/sdf-add-columns';
+import {sdfSaveTable} from '../utils/sdf-save-table';
 
-function parseStrandsFromDuplexCell(s: string): {SS: string, AS: string} {
-  const arr = s
-    .slice(CELL_STRUCTURE.DUPLEX.BEFORE_SS.length)
-    .split(CELL_STRUCTURE.DUPLEX.BEFORE_AS);
-  return {SS: arr[0], AS: arr[1]};
+const enum SEQ_TYPE {
+  AS = 'AS',
+  SS = 'SS',
+  DUPLEX = 'Duplex',
+  DIMER = 'Dimer',
 }
 
-function parseStrandsFromTriplexOrDimerCell(s: string): {SS: string, AS1: string, AS2: string} {
-  const arr1 = s
-    .slice(CELL_STRUCTURE.TRIPLEX_OR_DIMER.BEFORE_SS.length)
-    .split(CELL_STRUCTURE.TRIPLEX_OR_DIMER.BEFORE_AS1);
-  const arr2 = arr1[1]
-    .split(CELL_STRUCTURE.TRIPLEX_OR_DIMER.BEFORE_AS2);
-  return {SS: arr1[0], AS1: arr2[0], AS2: arr2[1]};
+/** Computable classes of sequence types */
+const enum SEQ_TYPE_CLASS {
+  AS_OR_SS,
+  DUPLEX,
+  DIMER,
 }
 
-async function saveTableAsSdFile(table: DG.DataFrame) {
-  if (GENERATED_COL_NAMES.some((colName) => !table.columns.contains(colName))) {
-    const absentColNames = differenceOfTwoArrays(GENERATED_COL_NAMES, table.columns.names()).join(`', '`);
-    grok.shell.warning(`File saved without columns '${absentColNames}'`);
-  }
+/** Style used for a cell with invalid value  */
+const errorStyle = {
+  'background-color': '#ff8080',
+  'width': '100%',
+  'height': '100%',
+};
+
+export function sdfHandleErrorUI(msgPrefix: string, df: DG.DataFrame, rowI: number, err: any) {
+  const errStr: string = err.toString();
+  const errMsg: string = msgPrefix + `row #${rowI + 1}, name: '${df.get('Chemistry Name', rowI)}', ` +
+    `type: ${df.get('Type', rowI)} error: ${errStr}.`;
+  grok.shell.warning(errMsg);
+}
 
-  const sequenceCol = table.getCol(COL_NAMES.SEQUENCE);
-  const typeCol = table.getCol(COL_NAMES.TYPE);
+// todo: use a dictionary instead?
+function getActualTypeClass(actualType: string): SEQ_TYPE_CLASS {
+  if (actualType === SEQ_TYPE.AS || actualType === SEQ_TYPE.SS)
+    return SEQ_TYPE_CLASS.AS_OR_SS;
+  else if (actualType === SEQ_TYPE.DIMER)
+    return SEQ_TYPE_CLASS.DIMER;
+  else if (actualType === SEQ_TYPE.DUPLEX)
+    return SEQ_TYPE_CLASS.DUPLEX;
+  else
+    throw new Error('Some types in \'Types\' column are invalid ');
+}
 
-  let result = '';
-  for (let i = 0; i < table.rowCount; i++) {
-    const format = SYNTHESIZERS.GCRS; //getFormat(sequenceCol.get(i))!;
-    if (typeCol.get(i) == SEQUENCE_TYPES.SENSE_STRAND)
-      result += `${sequenceToMolV3000(sequenceCol.get(i), false, true, format)}\n> <Sequence>\nSense Strand\n\n`;
-    else if (typeCol.get(i) == SEQUENCE_TYPES.ANTISENSE_STRAND)
-      result += `${sequenceToMolV3000(sequenceCol.get(i), true, true, format)}\n> <Sequence>\nAnti Sense\n\n`;
-    else if (typeCol.get(i) == SEQUENCE_TYPES.DUPLEX) {
-      const obj = parseStrandsFromDuplexCell(sequenceCol.get(i));
-      const as = `${sequenceToMolV3000(obj.AS, true, true, format)}\n> <Sequence>\nAnti Sense\n\n`;
-      const ss = `${sequenceToMolV3000(obj.SS, false, true, format)}\n> <Sequence>\nSense Strand\n\n`;
-      result += `${linkStrandsV3000({senseStrands: [ss], antiStrands: [as]}, true)}\n\n`;
-    } else if ([SEQUENCE_TYPES.TRIPLEX, SEQUENCE_TYPES.DIMER].includes(typeCol.get(i))) {
-      const obj = parseStrandsFromTriplexOrDimerCell(sequenceCol.get(i));
-      const as1 = `${sequenceToMolV3000(obj.AS1, true, true, format)}\n> <Sequence>\nAnti Sense\n\n`;
-      const as2 = `${sequenceToMolV3000(obj.AS2, true, true, format)}\n> <Sequence>\nAnti Sense\n\n`;
-      const ss = `${sequenceToMolV3000(obj.SS, false, true, format)}\n> <Sequence>\nSense Strand\n\n`;
-      result += `${linkStrandsV3000({senseStrands: [ss], antiStrands: [as1, as2]}, true)}\n\n`;
-    }
+function inferTypeClassFromSequence(seq: string): SEQ_TYPE_CLASS {
+  const lines = seq.split('\n');
+  if (lines.length === 1)
+    return SEQ_TYPE_CLASS.AS_OR_SS;
+  else if (lines.length === 2)
+    return SEQ_TYPE_CLASS.DUPLEX;
+  else if (lines.length === 3)
+    return SEQ_TYPE_CLASS.DIMER;
+  else
+    throw new Error('Wrong formatting of sequences in \'Sequence\' column');
+  //todo: throw in the case of wrong formatting
+}
+
+/** Compare type specified in 'Type' column to that computed from 'Sequence' column  */
+function validateType(actualType: string, seq: string): boolean {
+  return getActualTypeClass(actualType) === inferTypeClassFromSequence(seq);
+}
 
-    for (const col of table.columns) {
-      if (col.name != COL_NAMES.SEQUENCE)
-        result += `> <${col.name}>\n${col.get(i)}\n\n`;
+function oligoSdFileGrid(view: DG.TableView): void {
+  const typeColName = 'Type';
+  const seqColName = 'Sequence';
+  const grid = view.grid;
+  const df = view.dataFrame;
+  const typeCol = df.getCol(typeColName);
+  grid.columns.byName(typeColName)!.cellType = 'html';
+  const seqCol = df.getCol(seqColName);
+  grid.onCellPrepare((gridCell: DG.GridCell) => {
+    if (gridCell.isTableCell && gridCell.gridColumn.column!.name === typeColName) {
+      const isValidType = validateType(gridCell.cell.value, seqCol.get(gridCell.tableRow!.idx));
+      gridCell.style.element = ui.div(gridCell.cell.value, isValidType ? {} : {style: errorStyle});
     }
-    result += '$$$$\n';
-  }
-  download(`${table.name}.sdf`, encodeURIComponent(result));
+  });
 }
 
 export function autostartOligoSdFileSubscription() {
   grok.events.onViewAdded.subscribe((v: any) => {
-    if (v.type == DG.VIEW_TYPE.TABLE_VIEW) {
-      if (v.dataFrame.columns.contains(COL_NAMES.TYPE))
+    if (v.type === DG.VIEW_TYPE.TABLE_VIEW) {
+      if (v.dataFrame.columns.contains(COL_NAMES.TYPE)) {
+        oligoSdFileGrid(v);
         oligoSdFile(v.dataFrame);
+      }
 
       // Should be removed after fixing bug https://github.com/datagrok-ai/public/issues/808
       grok.events.onContextMenu.subscribe((args) => {
-        const seqCol = args.args.context.table.currentCol; // /^[fsACGUacgu]{6,}$/
+        if (!(args.args.context instanceof DG.Grid)) return;
+        const grid: DG.Grid = args.args.context as DG.Grid;
+        const menu: DG.Menu = args.args.menu;
+
+        const seqCol = grid.table.currentCol; // /^[fsACGUacgu]{6,}$/
         if (DG.Detector.sampleCategories(seqCol,
           (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|A|U|G|C){6,}$/.test(s))) {
-          args.args.menu.item('Convert raw nucleotides to GCRS', () => {
-            args.args.context.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
+          menu.item('Convert raw nucleotides to GCRS', () => {
+            grid.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
               return siRnaNucleotidesToGcrs(seqCol.get(i));
             });
           });
         } else if (DG.Detector.sampleCategories(seqCol,
           (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|f|s|A|C|G|U|a|c|g|u){6,}$/.test(s))) {
-          args.args.menu.item('Convert Axolabs to GCRS', () => {
-            args.args.context.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
+          menu.item('Convert Axolabs to GCRS', () => {
+            grid.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
               return siRnaAxolabsToGcrs(seqCol.get(i));
             });
           }); // /^[fmpsACGU]{6,}$/
         } else if (DG.Detector.sampleCategories(seqCol,
-          (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|f|m|ps|A|C|G|U){6,}$/.test(s)) ||
-        DG.Detector.sampleCategories(seqCol, (s) => /^(?=.*moe)(?=.*5mC)(?=.*ps){6,}/.test(s))) {
-          args.args.menu.item('Convert GCRS to raw', () => {
-            args.args.context.table.columns.addNewString(seqCol.name + ' to raw').init((i: number) => {
+            (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|f|m|ps|A|C|G|U){6,}$/.test(s)) ||
+          DG.Detector.sampleCategories(seqCol, (s) => /^(?=.*moe)(?=.*5mC)(?=.*ps){6,}/.test(s))) {
+          menu.item('Convert GCRS to raw', () => {
+            grid.table.columns.addNewString(seqCol.name + ' to raw').init((i: number) => {
               return gcrsToNucleotides(seqCol.get(i));
             });
           });
-          args.args.menu.item('Convert GCRS to MM12', () => {
-            args.args.context.table.columns.addNewString(seqCol.name + ' to MM12').init((i: number) => {
+          menu.item('Convert GCRS to MM12', () => {
+            grid.table.columns.addNewString(seqCol.name + ' to MM12').init((i: number) => {
               return gcrsToMermade12(seqCol.get(i));
             });
           }); // /^[*56789ATGC]{6,}$/
         } else if (DG.Detector.sampleCategories(seqCol,
           (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|\*|5|6|7|8|9|A|T|G|C){6,}$/.test(s))) {
-          args.args.menu.item('Convert Biospring to GCRS', () => {
-            const seqCol = args.args.context.table.currentCol;
-            args.args.context.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
+          menu.item('Convert Biospring to GCRS', () => {
+            const seqCol = grid.table.currentCol;
+            grid.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
               return asoGapmersBioSpringToGcrs(seqCol.get(i));
             });
           }); // /^[*1-8]{6,}$/
         } else if (DG.Detector.sampleCategories(seqCol,
           (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|\*|1|2|3|4|5|6|7|8){6,}$/.test(s))) {
-          args.args.menu.item('Convert Biospring to GCRS', () => {
-            args.args.context.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
+          menu.item('Convert Biospring to GCRS', () => {
+            grid.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
               return siRnaBioSpringToGcrs(seqCol.get(i));
             });
           });
@@ -136,85 +166,13 @@ export function oligoSdFile(table: DG.DataFrame) {
   const icdsDf = DG.DataFrame.fromCsv(ICDS);
   const idpsDf = DG.DataFrame.fromCsv(IDPS);
 
-  const sequenceCol = table.getCol(COL_NAMES.SEQUENCE);
   const saltCol = table.getCol(COL_NAMES.SALT);
   const equivalentsCol = table.getCol(COL_NAMES.EQUIVALENTS);
-  const typeCol = table.getCol(COL_NAMES.TYPE);
-  const chemistryNameCol = table.getCol(COL_NAMES.CHEMISTRY_NAME);
-
-  const molWeightCol = saltsDf.getCol('MOLWEIGHT');
-  const saltNamesList = saltsDf.getCol('DISPLAY').toList();
-
-  let newDf: DG.DataFrame;
-  let addColumnsPressed = false;
 
-  function addColumns(t: DG.DataFrame) {
-    if (GENERATED_COL_NAMES.some((colName) => t.columns.contains(colName)))
-      return grok.shell.error('Columns already exist');
+  const saltsMolWeightList: number[] = saltsDf.getCol('MOLWEIGHT').toList();
+  const saltNamesList: string[] = saltsDf.getCol('DISPLAY').toList();
 
-    t = removeEmptyRows(t, sequenceCol);
-
-    t.columns.addNewString(COL_NAMES.COMPOUND_NAME).init((i: number) => {
-      return ([SEQUENCE_TYPES.DUPLEX, SEQUENCE_TYPES.DIMER, SEQUENCE_TYPES.TRIPLEX].includes(typeCol.get(i))) ?
-        chemistryNameCol.get(i) :
-        sequenceCol.get(i);
-    });
-
-    t.columns.addNewString(COL_NAMES.COMPOUND_COMMENTS).init((i: number) => {
-      if ([SEQUENCE_TYPES.SENSE_STRAND, SEQUENCE_TYPES.ANTISENSE_STRAND].includes(typeCol.get(i)))
-        return sequenceCol.get(i);
-      else if (typeCol.get(i) == SEQUENCE_TYPES.DUPLEX) {
-        const obj = parseStrandsFromDuplexCell(sequenceCol.get(i));
-        return `${chemistryNameCol.get(i)}; duplex of SS: ${obj.SS} and AS: ${obj.AS}`;
-      } else if ([SEQUENCE_TYPES.DIMER, SEQUENCE_TYPES.TRIPLEX].includes(typeCol.get(i))) {
-        const obj = parseStrandsFromTriplexOrDimerCell(sequenceCol.get(i));
-        return `${chemistryNameCol.get(i)}; duplex of SS: ${obj.SS} and AS1: ${obj.AS1} and AS2: ${obj.AS2}`;
-      }
-    });
-
-    t.columns.addNewFloat(COL_NAMES.COMPOUND_MOL_WEIGHT).init((i: number) => {
-      if ([SEQUENCE_TYPES.SENSE_STRAND, SEQUENCE_TYPES.ANTISENSE_STRAND].includes(typeCol.get(i))) {
-        return (isValidSequence(sequenceCol.get(i), null).indexOfFirstNotValidChar == -1) ?
-          molecularWeight(sequenceCol.get(i), weightsObj) :
-          DG.FLOAT_NULL;
-      } else if (typeCol.get(i) == SEQUENCE_TYPES.DUPLEX) {
-        const obj = parseStrandsFromDuplexCell(sequenceCol.get(i));
-        return (Object.values(obj).every((seq) => isValidSequence(seq, null).indexOfFirstNotValidChar == -1)) ?
-          molecularWeight(obj.SS, weightsObj) + molecularWeight(obj.AS, weightsObj) :
-          DG.FLOAT_NULL;
-      } else if ([SEQUENCE_TYPES.DIMER, SEQUENCE_TYPES.TRIPLEX].includes(typeCol.get(i))) {
-        const obj = parseStrandsFromTriplexOrDimerCell(sequenceCol.get(i));
-        return (Object.values(obj).every((seq) => isValidSequence(seq, null).indexOfFirstNotValidChar == -1)) ?
-          molecularWeight(obj.SS, weightsObj) + molecularWeight(obj.AS1, weightsObj) +
-          molecularWeight(obj.AS2, weightsObj) :
-          DG.FLOAT_NULL;
-      }
-    });
-
-    t.columns.addNewFloat(COL_NAMES.SALT_MASS).init((i: number) =>
-      saltMass(saltNamesList, molWeightCol, equivalentsCol, i, saltCol));
-
-    t.columns.addNewFloat(COL_NAMES.SALT_MOL_WEIGHT).init((i: number) =>
-      saltMolWeigth(saltNamesList, saltCol, molWeightCol, i));
-
-    const compoundMolWeightCol = t.getCol(COL_NAMES.COMPOUND_MOL_WEIGHT);
-    const saltMassCol = t.getCol(COL_NAMES.SALT_MASS);
-    t.columns.addNewFloat(COL_NAMES.BATCH_MOL_WEIGHT).init((i: number) =>
-      batchMolWeight(compoundMolWeightCol, saltMassCol, i));
-
-    grok.shell.getTableView(table.name).grid.columns.setOrder(Object.values(COL_NAMES));
-    addColumnsPressed = true;
-    return newDf = t;
-  }
-
-  function updateCalculatedColumns(t: DG.DataFrame, i: number): void {
-    const smValue = saltMass(saltNamesList, molWeightCol, equivalentsCol, i, saltCol);
-    t.getCol(COL_NAMES.SALT_MASS).set(i, smValue, false);
-    const smwValue = saltMolWeigth(saltNamesList, saltCol, molWeightCol, i);
-    t.getCol(COL_NAMES.SALT_MOL_WEIGHT).set(i, smwValue, false);
-    const bmw = batchMolWeight(t.getCol(COL_NAMES.COMPOUND_MOL_WEIGHT), t.getCol(COL_NAMES.SALT_MASS), i);
-    t.getCol(COL_NAMES.BATCH_MOL_WEIGHT).set(i, bmw, false);
-  }
+  let newDf: DG.DataFrame | undefined = undefined;
 
   const d = ui.div([
     ui.icons.edit(() => {
@@ -223,9 +181,19 @@ export function oligoSdFile(table: DG.DataFrame) {
         table.changeColumnType(COL_NAMES.IDP, DG.COLUMN_TYPE.STRING);
       d.append(
         ui.divH([
-          ui.icons.add(() => addColumns(table), `Add columns: '${GENERATED_COL_NAMES.join(`', '`)}'`),
-          ui.icons.save(() => saveTableAsSdFile(addColumnsPressed ? newDf : table), 'Save SD file'),
-        ]),
+          ui.button('Add columns',
+            () => {
+              newDf = sdfAddColumns(table, saltNamesList, saltsMolWeightList,
+                (rowI, err) => { sdfHandleErrorUI('Error on ', table, rowI, err); });
+              grok.shell.getTableView(newDf.name).grid.columns.setOrder(Object.values(COL_NAMES));
+            },
+            `Add columns: '${GENERATED_COL_NAMES.join(`', '`)}'`),
+          ui.bigButton('Save SDF', () => {
+            const df: DG.DataFrame = newDf ?? table;
+            sdfSaveTable(df,
+              (rowI, err) => { sdfHandleErrorUI('Skip ', df, rowI, err); });
+          }, 'Save SD file'),
+        ])
       );
 
       const view = grok.shell.getTableView(table.name);
@@ -238,11 +206,15 @@ export function oligoSdFile(table: DG.DataFrame) {
       view.dataFrame.getCol(COL_NAMES.IDP).setTag(DG.TAGS.CHOICES, stringify(idpsDf.columns.byIndex(0).toList()));
 
       grok.events.onContextMenu.subscribe((args) => {
+        if (!(args.args.context instanceof DG.Grid)) return;
+        const grid: DG.Grid = args.args.context as DG.Grid;
+        const menu: DG.Menu = args.args.menu;
+
         if ([COL_NAMES.TYPE, COL_NAMES.OWNER, COL_NAMES.SALT, COL_NAMES.SOURCE, COL_NAMES.ICD, COL_NAMES.IDP]
-          .includes(args.args.context.table.currentCol.name)) {
-          args.args.menu.item('Fill Column With Value', () => {
-            const v = args.args.context.table.currentCell.value;
-            args.args.context.table.currentCell.column.init(v);
+          .includes(grid.table.currentCol.name)) {
+          menu.item('Fill Column With Value', () => {
+            const v = grid.table.currentCell.value;
+            grid.table.currentCell.column.init(v);
             for (let i = 0; i < view.dataFrame.rowCount; i++)
               updateCalculatedColumns(view.dataFrame, i);
           });
@@ -256,9 +228,9 @@ export function oligoSdFile(table: DG.DataFrame) {
       });
 
       function updateCalculatedColumns(t: DG.DataFrame, i: number): void {
-        const smValue = saltMass(saltNamesList, molWeightCol, equivalentsCol, i, saltCol);
+        const smValue = saltMass(saltNamesList, saltsMolWeightList, equivalentsCol, i, saltCol);
         t.getCol(COL_NAMES.SALT_MASS).set(i, smValue, false);
-        const smwValue = saltMolWeigth(saltNamesList, saltCol, molWeightCol, i);
+        const smwValue = saltMolWeigth(saltNamesList, saltCol, saltsMolWeightList, i);
         t.getCol(COL_NAMES.SALT_MOL_WEIGHT).set(i, smwValue, false);
         const bmw = batchMolWeight(t.getCol(COL_NAMES.COMPOUND_MOL_WEIGHT), t.getCol(COL_NAMES.SALT_MASS), i);
         t.getCol(COL_NAMES.BATCH_MOL_WEIGHT).set(i, bmw, false);