@datagrok/sequence-translator 1.0.3 → 1.0.6

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.0.3",
+  "version": "1.0.6",
+  "author": {
+    "name": "Vadym Kovadlo",
+    "email": "vkovadlo@datagrok.ai"
+  },
   "description": "SequenceTranslator is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform, used to translate [oligonucleotide](https://en.wikipedia.org/wiki/Oligonucleotide) sequences between [different representations](https://github.com/datagrok-ai/public/tree/master/packages/SequenceTranslator#sequence-representations).",
   "repository": {
     "type": "git",
@@ -10,46 +14,51 @@
   },
   "dependencies": {
     "@datagrok-libraries/utils": "^0.1.0",
-    "@types/react": "latest",
-    "datagrok-api": "^1.1.7",
+    "@types/react": "^18.0.15",
+    "datagrok-api": "^1.6.0",
     "datagrok-tools": "^4.1.2",
     "npm": "^8.11.0",
+    "openchemlib": "6.0.1",
     "save-svg-as-png": "^1.4.17",
-    "ts-loader": "latest",
-    "typescript": "latest",
-    "openchemlib": "6.0.1"
+    "ts-loader": "^9.3.1",
+    "typescript": "^4.7.4"
   },
   "scripts": {
     "link-api": "npm link datagrok-api",
-    "debug-sequencetranslator": "grok publish --rebuild",
-    "release-sequencetranslator": "grok publish --rebuild --release",
+    "debug-sequencetranslator": "grok publish",
+    "release-sequencetranslator": "grok publish localhost --release",
     "build-sequencetranslator": "webpack",
     "build": "webpack",
-    "debug-sequencetranslator-public": "grok publish public --rebuild",
-    "release-sequencetranslator-public": "grok publish public --rebuild --release",
-    "debug-sequencetranslator-local": "grok publish local --rebuild",
-    "release-sequencetranslator-local": "grok publish local --rebuild --release",
-    "test": "set HOST=dev && jest",
+    "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",
-    "common/openchemlib-full.js"
+    "vendors/openchemlib-full.js"
   ],
   "devDependencies": {
+    "@types/jest": "^27.0.0",
+    "@types/jquery": "^3.5.14",
     "@typescript-eslint/eslint-plugin": "^4.29.1",
     "@typescript-eslint/parser": "^4.29.1",
     "cash-dom": "^8.1.0",
     "eslint": "^7.32.0",
     "eslint-config-google": "^0.14.0",
-    "webpack": "^5.31.0",
-    "webpack-cli": "^4.6.0",
-    "jest-html-reporter": "^3.5.0",
     "jest": "^27.0.0",
-    "@types/jest": "^27.0.0",
+    "jest-html-reporter": "^3.5.0",
+    "puppeteer": "^13.7.0",
     "ts-jest": "^27.0.0",
-    "puppeteer": "^13.7.0"
+    "webpack": "^5.31.0",
+    "webpack-cli": "^4.6.0",
+    "@types/js-yaml": "^4.0.5",
+    "js-yaml": "^4.1.0",
+    "@types/node-fetch": "^2.6.2",
+    "node-fetch": "^2.6.7"
   },
   "category": "Bioinformatics"
 }

package/src/__jest__/remote.test.ts

@@ -5,7 +5,7 @@
 import * as utils from './test-node';
 import puppeteer from 'puppeteer';
 
-const P_START_TIMEOUT: number = 100000;
+const P_START_TIMEOUT: number = 3600000;
 let browser: puppeteer.Browser;
 let page: puppeteer.Page;
 
@@ -16,34 +16,53 @@ beforeAll(async () => {
 }, P_START_TIMEOUT);
 
 afterAll(async () => {
-  await browser.close();
+  await browser?.close();
+});
+
+expect.extend({
+  checkOutput(received, expected, context) {
+    if (received === expected) {
+      return {
+        message: () => context,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => context,
+        pass: false
+      };
+    }
+  }
 });
 
 it('TEST', async () => {
-  const target_package:string = process.env.TARGET_PACKAGE ?? 'SequenceTranslator';
-  console.log(`Testing ${target_package} package`);
+  const targetPackage:string = process.env.TARGET_PACKAGE ?? 'SequenceTranslator';
+  console.log(`Testing ${targetPackage} package`);
 
-  //console.log(require('root-require')('package.json').version);
-  let r = await page.evaluate((target_package):Promise<object> => {
+  let r = await page.evaluate((targetPackage):Promise<object> => {
     return new Promise<object>((resolve, reject) => {
-      (<any>window).grok.functions.eval(target_package + ':test()').then((df: any) => {
+      (<any>window).grok.functions.eval(targetPackage + ':test()').then((df: any) => {
         let cStatus = df.columns.byName('success');
         let cMessage = df.columns.byName('result');
         let cCat = df.columns.byName('category');
         let cName = df.columns.byName('name');
         let failed = false;
-        let report = '';
-        for (let i = 0; i < df.rowCount; i++)
-          if (!cStatus.get(i)) {
-            report += `${cCat.get(i)}.${cName.get(i)}: ${cMessage.get(i)}\n`;
+        let passReport = '';
+        let failReport = '';
+        for (let i = 0; i < df.rowCount; i++) {
+          if (cStatus.get(i)) {
+            passReport += `Test result : Success : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
+          } else {
             failed = true;
+            failReport += `Test result : Failed : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
           }
-        resolve({report, failed});
+        }
+        resolve({failReport, passReport, failed});
       }).catch((e: any) => reject(e));
     });
-  }, target_package);
+  }, targetPackage);
   // @ts-ignore
-  console.log(r.report);
+  console.log(r.passReport);
   // @ts-ignore
-  expect(r.failed).toBe(false);
-}, 100000);
+  expect(r.failed).checkOutput(false, r.failReport);
+}, 3600000);

package/src/__jest__/test-node.ts

@@ -67,6 +67,7 @@ export async function getBrowserPage(puppeteer: any): Promise<{browser: any, pag
   });
 
   let page = await browser.newPage();
+  await page.setDefaultNavigationTimeout(0);
   await page.goto(`${url}/oauth/`);
   await page.setCookie({name: 'auth', value: token});
   await page.evaluate((token: any) => {
@@ -74,8 +75,8 @@ export async function getBrowserPage(puppeteer: any): Promise<{browser: any, pag
   }, token);
   await page.goto(url);
   try {
-    await page.waitForSelector('.grok-preloader');
-    await page.waitForFunction(() => document.querySelector('.grok-preloader') == null, {timeout: 100000});
+    await page.waitForSelector('.grok-preloader', { timeout: 1800000 });
+    await page.waitForFunction(() => document.querySelector('.grok-preloader') == null, {timeout: 3600000});
   } catch (error) {
     throw error;
   }

package/src/autostart/registration.ts

@@ -0,0 +1,206 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {siRnaAxolabsToGcrs, gcrsToNucleotides, asoGapmersBioSpringToGcrs, gcrsToMermade12,
+} from '../structures-works/converters';
+import {map, COL_NAMES, MODIFICATIONS} from '../structures-works/map';
+import {getFormat, isValidSequence} from '../structures-works/sequence-codes-tools';
+import {sequenceToMolV3000} from '../structures-works/from-monomers';
+
+import {SALTS_CSV} from '../salts';
+import {USERS_CSV} from '../users';
+import {ICDS} from '../ICDs';
+import {SOURCES} from '../sources';
+import {IDPS} from '../IDPs';
+
+
+function sortByStringLengthInDescendingOrder(array: string[]): string[] {
+  return array.sort(function(a, b) {return b.length - a.length;});
+}
+
+function stringify(items: string[]): string {
+  return '["' + items.join('", "') + '"]';
+}
+
+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;
+  while (i < sequence.length) {
+    const matchedCode = codes.find((s) => s == sequence.slice(i, i + s.length))!;
+    weight += weightsObj[sequence.slice(i, i + matchedCode.length)];
+    i += matchedCode.length;
+  }
+  return weight - 61.97;
+}
+
+async function saveTableAsSdFile(table: DG.DataFrame) {
+  if (!table.columns.contains('Compound Name')) {
+    grok.shell.warning(
+      'File saved without columns \'' +
+      [COL_NAMES.COMPOUND_NAME, COL_NAMES.COMPOUND_COMMENTS, COL_NAMES.CPD_MW,
+        COL_NAMES.SALT_MASS, COL_NAMES.BATCH_MW].join('\', \''),
+    );
+  }
+  const structureColumn = table.getCol(COL_NAMES.SEQUENCE);
+  const typeColumn = table.getCol(COL_NAMES.TYPE);
+  let result = '';
+  for (let i = 0; i < table.rowCount; i++) {
+    const format = 'Janssen GCRS Codes'; //getFormat(structureColumn.get(i))!;
+    result += (typeColumn.get(i) == 'SS') ?
+      sequenceToMolV3000(structureColumn.get(i), false, true, format) + '\n' + `>  <Sequence>\nSense Strand\n\n` :
+      sequenceToMolV3000(structureColumn.get(i), true, true, format) + '\n' + `>  <Sequence>\nAnti Sense\n\n`;
+    for (const col of table.columns) {
+      if (col.name != COL_NAMES.SEQUENCE)
+        result += `>  <${col.name}>\n${col.get(i)}\n\n`;
+    }
+    result += '$$$$\n\n';
+  }
+  const element = document.createElement('a');
+  element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(result));
+  element.setAttribute('download', table.name + '.sdf');
+  element.click();
+}
+
+export function autostartOligoSdFileSubscription() {
+  grok.events.onViewAdded.subscribe((v: any) => {
+    if (v.type == 'TableView') {
+      if (v.dataFrame.columns.contains(COL_NAMES.TYPE))
+        oligoSdFile(v.dataFrame);
+      grok.events.onContextMenu.subscribe((args) => {
+        const seqCol = args.args.context.table.currentCol; // /^[fsACGUacgu]{6,}$/
+        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) => {
+              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) => {
+              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) => {
+              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) => {
+              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) => {
+              return siRnaAxolabsToGcrs(seqCol.get(i));
+            });
+          });
+        }
+      });
+    }
+  });
+}
+
+export function oligoSdFile(table: DG.DataFrame) {
+  const saltsDf = DG.DataFrame.fromCsv(SALTS_CSV);
+  const usersDf = DG.DataFrame.fromCsv(USERS_CSV);
+  const sourcesDf = DG.DataFrame.fromCsv(SOURCES);
+  const icdsDf = DG.DataFrame.fromCsv(ICDS);
+  const idpsDf = DG.DataFrame.fromCsv(IDPS);
+
+  async function addColumns(t: DG.DataFrame, saltsDf: DG.DataFrame) {
+    if (t.columns.contains(COL_NAMES.COMPOUND_NAME))
+      return grok.shell.error('Columns already exist');
+
+    const sequenceCol = t.getCol(COL_NAMES.SEQUENCE);
+    const saltCol = t.getCol(COL_NAMES.SALT);
+    const equivalentsCol = t.getCol(COL_NAMES.EQUIVALENTS);
+
+    t.columns.addNewString(COL_NAMES.COMPOUND_NAME).init((i: number) => sequenceCol.get(i));
+
+    t.columns.addNewString(COL_NAMES.COMPOUND_COMMENTS).init((i: number) => (i > 0 && i % 2 == 0) ?
+      sequenceCol.get(i) + '; duplex of SS: ' + sequenceCol.get(i - 2) + ' and AS: ' + sequenceCol.get(i - 1) :
+      sequenceCol.get(i),
+    );
+    const molWeightCol = saltsDf.getCol('MOLWEIGHT');
+    const saltNamesList = saltsDf.getCol('DISPLAY').toList();
+    const weightsObj: {[code: string]: number} = {};
+    for (const synthesizer of Object.keys(map)) {
+      for (const technology of Object.keys(map[synthesizer])) {
+        for (const code of Object.keys(map[synthesizer][technology]))
+          weightsObj[code] = map[synthesizer][technology][code].weight!;
+      }
+    }
+    for (const [key, value] of Object.entries(MODIFICATIONS))
+      weightsObj[key] = value.molecularWeight;
+
+    t.columns.addNewFloat(COL_NAMES.CPD_MW).init((i: number) => {
+      return (isValidSequence(sequenceCol.get(i), null).indexOfFirstNotValidChar == -1) ?
+        molecularWeight(sequenceCol.get(i), weightsObj) :
+        DG.FLOAT_NULL;
+    });
+
+    t.columns.addNewFloat(COL_NAMES.SALT_MASS).init((i: number) => {
+      const saltRowIndex = saltNamesList.indexOf(saltCol.get(i));
+      return (saltRowIndex == -1) ?
+        DG.FLOAT_NULL :
+        molWeightCol.get(saltRowIndex) * equivalentsCol.get(i);
+    });
+
+    await t.columns.addNewCalculated(COL_NAMES.BATCH_MW,
+      '${' + COL_NAMES.CPD_MW + '} + ${' + COL_NAMES.SALT_MASS + '}', DG.COLUMN_TYPE.FLOAT, false,
+    );
+
+    addColumnsPressed = true;
+    return newDf = t;
+  }
+
+  let newDf: DG.DataFrame;
+  let addColumnsPressed = false;
+
+  const d = ui.div([
+    ui.icons.edit(() => {
+      d.innerHTML = '';
+      if (table.getCol(COL_NAMES.IDP).type != DG.COLUMN_TYPE.STRING)
+        table.changeColumnType(COL_NAMES.IDP, DG.COLUMN_TYPE.STRING);
+      d.append(
+        ui.link('Add Columns', async () => {
+          await addColumns(table, saltsDf);
+          view.grid.columns.setOrder(Object.values(COL_NAMES));
+        }, 'Add columns: \'' + [COL_NAMES.COMPOUND_NAME, COL_NAMES.COMPOUND_COMMENTS, COL_NAMES.CPD_MW,
+          COL_NAMES.SALT_MASS, COL_NAMES.BATCH_MW].join('\', \''), '',
+        ),
+        ui.button('Save SD file', () => saveTableAsSdFile(addColumnsPressed ? newDf : table)),
+      );
+
+      const view = grok.shell.getTableView(table.name);
+
+      view.dataFrame.getCol(COL_NAMES.TYPE).setTag(DG.TAGS.CHOICES, '["AS", "SS", "Duplex"]');
+      view.dataFrame.getCol(COL_NAMES.OWNER).setTag(DG.TAGS.CHOICES, stringify(usersDf.columns.byIndex(0).toList()));
+      view.dataFrame.getCol(COL_NAMES.SALT).setTag(DG.TAGS.CHOICES, stringify(saltsDf.columns.byIndex(0).toList()));
+      view.dataFrame.getCol(COL_NAMES.SOURCE).setTag(DG.TAGS.CHOICES, stringify(sourcesDf.columns.byIndex(0).toList()));
+      view.dataFrame.getCol(COL_NAMES.ICD).setTag(DG.TAGS.CHOICES, stringify(icdsDf.columns.byIndex(0).toList()));
+      view.dataFrame.getCol(COL_NAMES.IDP).setTag(DG.TAGS.CHOICES, stringify(idpsDf.columns.byIndex(0).toList()));
+
+      grok.events.onContextMenu.subscribe((args) => {
+        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);
+          });
+        }
+      });
+    }),
+  ]);
+  grok.shell.v.setRibbonPanels([[d]]);
+}

package/src/{axolabsMap.ts → axolabs/constants.ts}

@@ -94,7 +94,7 @@ export const axolabsMap:
     color: invAbasicColor,
   },
   '2\'-OMe-U(o)': {
-    fullName: 'Nucleotide Uridine with 2’O-Methyl protection (overhang)',
+    fullName: 'Nucleotide Uridine with 2\'O-Methyl protection (overhang)',
     symbols: ['mU', 'mU', 'mU', 'mU'],
     color: 'rgb(65,233,80)',
   },