@datagrok/sequence-translator 1.0.12 → 1.0.14

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "author": {
-    "name": "Vadym Kovadlo",
-    "email": "vkovadlo@datagrok.ai"
+    "name": "Alexey Choposky",
+    "email": "achopovsky@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": {
@@ -13,8 +13,9 @@
     "directory": "packages/SequenceTranslator"
   },
   "dependencies": {
-    "@datagrok-libraries/utils": "^1.11.1",
+    "@datagrok-libraries/utils": "^1.15.5",
     "@types/react": "^18.0.15",
+    "@datagrok-libraries/bio": "^5.11.1",
     "datagrok-api": "^1.7.2",
     "datagrok-tools": "^4.1.2",
     "npm": "^8.11.0",
@@ -25,6 +26,7 @@
   },
   "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",

package/scripts/build-monomer-lib.py

@@ -0,0 +1,140 @@
+from io import TextIOWrapper
+
+from rdkit.Chem import AllChem
+from rdkit import Chem
+
+import orjson
+import json
+
+import click
+
+from click_default_group import DefaultGroup
+from rdkit.Chem.rdchem import Mol
+
+
+def smiles2molfile(smiles: str) -> str:
+    mol: Mol = Chem.MolFromSmiles(smiles)
+    res: str = Chem.MolToMolBlock(mol, forceV3000=True)  # MolToMolFile
+    return res
+
+
+def molV2000toMolV3000(molV2K: str) -> str:
+    mol: str = Chem.MolFromMolBlock(molV2K)
+    res: str = Chem.MolToMolBlock(mol, forceV3000=True)
+    return res.replace('Pol', 'O  ')
+
+
+CodesType = dict[str, dict[str, list[str]]]
+
+
+class Monomer:
+    def __init__(self,
+                 symbol: str, name: str, smiles: str,
+                 codes: CodesType):
+        self.monomerType = 'Backbone'
+        self.smiles = smiles
+        self.name = name
+        self.author = 'SequenceTranslator'
+        self.molfile = smiles2molfile(smiles)
+        self.naturalAnalog = ''
+        self.rgroups = [
+            {
+                "capGroupSmiles": "O[*:1]",
+                "alternateId": "R1-OH",
+                "capGroupName": "OH",
+                "label": "R1"
+            },
+            {
+                "capGroupSmiles": "O[*:2]",
+                "alternateId": "R2-OH",
+                "capGroupName": "OH",
+                "label": "R2"
+            }]
+        self.createDate = None
+        self.id = 0
+        self.polymerType = 'RNA'
+        self.symbol = symbol
+        self.codes: CodesType = codes
+
+    @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']
+        return obj
+
+    def to_json(self):
+        return {
+            'monomerType': self.monomerType,
+            'smiles': self.smiles,
+            'name': self.name,
+            'author': self.author,
+            'molfile': self.molfile,
+            'naturalAnalog': self.naturalAnalog,
+            'rgroups': self.rgroups,
+            'createDate': self.createDate,
+            'id': self.id,
+            'polymerType': self.polymerType,
+            'symbol': self.symbol,
+            'codes': self.codes,
+        }
+
+
+def codes2monomers(codes_json: {}) -> dict[str, Monomer]:
+    monomers_res: dict[str, Monomer] = {}
+    for (codes_src, src_dict) in codes_json.items():
+        for (codes_type, monomers_dict) in src_dict.items():
+            for (codes_code, monomer_json) in monomers_dict.items():
+                monomer_name = monomer_json['name']
+                if monomer_name not in monomers_res:
+                    symbol = monomer_json['name']
+                    name = monomer_json['name']
+                    smiles = monomer_json['SMILES']
+                    monomers_res[monomer_name] = Monomer(symbol, name, smiles, {})
+                codes = monomers_res[monomer_name].codes
+                if codes_src not in codes:
+                    codes[codes_src] = {}
+                if codes_type not in codes[codes_src]:
+                    codes[codes_src][codes_type] = [];
+                codes[codes_src][codes_type].append(codes_code)
+    return monomers_res
+
+
+@click.group(cls=DefaultGroup, default='main')
+def cli():
+    pass
+
+
+@cli.command()
+@click.pass_context
+@click.option('--initial', 'initial_f',
+              help='Initial monomers source file.',
+              type=click.File('r', 'utf-8'))
+@click.option('--lib', 'lib_f',
+              help='Output library (HELM format) file.',
+              type=click.File('wb', 'utf-8'))
+@click.option('--add', 'add_f_list', multiple=True,
+              help='Additional libraries to build.',
+              type=click.File('r', 'utf-8'))
+def main(ctx, initial_f: TextIOWrapper, lib_f: TextIOWrapper, add_f_list: list[TextIOWrapper]):
+    initial_json_str = initial_f.read()
+
+    initial_json = orjson.loads(initial_json_str)
+
+    monomers: dict[str, Monomer] = codes2monomers(initial_json)
+
+    for add_f in add_f_list:
+        add_json_str = add_f.read()
+        add_json = orjson.loads(add_json_str)
+        for add_m in add_json:
+            m = Monomer.from_json(add_m)
+            monomers[m.name] = m
+
+    add_json = [m.to_json() for m in monomers.values()]
+
+    lib_json_txt = orjson.dumps(add_json, option=orjson.OPT_INDENT_2)
+    lib_f.write(lib_json_txt)
+    k = 11
+
+
+if __name__ == '__main__':
+    cli()

package/setup-unlink-clean.cmd

@@ -0,0 +1,14 @@
+set package_dir=%cd%
+
+set dirs=^
+\..\..\js-api\ ^
+\..\..\libraries\utils\ ^
+\..\..\libraries\bio\ ^
+\
+
+call npm uninstall -g datagrok-api @datagrok-libraries/utils @datagrok-libraries/bio
+
+for %%p in (%dirs%) do cd %package_dir%\%%p & rmdir /s /q node_modules
+for %%p in (%dirs%) do cd %package_dir%\%%p & rmdir /s /q dist
+
+rem for %%p in (%dirs%) do cd %package_dir%\%%p & del "package-lock.json"

package/setup.cmd

@@ -1,11 +1,14 @@
-cd ../../js-api
-call npm install
-call npm link
-cd ../libraries/utils
-call npm install
-call npm link
-call npm link datagrok-api
-cd ../../packages/SequenceTranslator
-call npm install
-call npm link datagrok-api @datagrok-libraries/utils
-webpack
+call setup-unlink-clean.cmd
+
+set package_dir=%cd%
+
+set dirs=^
+\..\..\js-api\ ^
+\..\..\libraries\utils\ ^
+\..\..\libraries\bio\ ^
+\
+
+for %%p in (%dirs%) do cd %package_dir%\%%p & call npm install
+for %%p in (%dirs%) do cd %package_dir%\%%p & call npm link
+for %%p in (%dirs%) do cd %package_dir%\%%p & call npm run link-all
+for %%p in (%dirs%) do cd %package_dir%\%%p & call npm run build

package/setup.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+./setup-unlink-clean.sh
+
+GREEN='\e[0;32m'
+NO_COLOR='\e[0m'
+
+package_dir=$(pwd)
+
+dirs=(
+  "../../js-api/"
+  "../../libraries/utils/"
+  "../../libraries/bio/"
+)
+
+for dir in ${dirs[@]}; do
+  cd $package_dir
+  cd $dir 
+  echo -e $GREEN npm install in $(pwd) $NO_COLOR
+  npm install 
+  echo -e $GREEN npm link in $(pwd) $NO_COLOR
+  npm link
+done
+
+for dir in ${dirs[@]}; do
+  cd $package_dir
+  cd $dir 
+  if [ $dir != "../../js-api/" ]; then
+    echo -e $GREEN npm link-all in $(pwd) $NO_COLOR
+    npm run link-all
+  fi
+  echo -e $GREEN npm run build in$(pwd) $NO_COLOR
+  npm run build || exit
+done
+
+cd $package_dir
+npm run link-all

package/src/__jest__/remote.test.ts

@@ -43,27 +43,35 @@ it('TEST', async () => {
     return new Promise<object>((resolve, reject) => {
       (<any>window).grok.functions.eval(targetPackage + ':test()').then((df: any) => {
         const cStatus = df.columns.byName('success');
+        const cSkipped = df.columns.byName('skipped');
         const cMessage = df.columns.byName('result');
         const cCat = df.columns.byName('category');
         const cName = df.columns.byName('name');
         const cTime = df.columns.byName('ms');
         let failed = false;
+        let skipReport = '';
         let passReport = '';
         let failReport = '';
         for (let i = 0; i < df.rowCount; i++) {
           if (cStatus.get(i)) {
-            passReport += `Test result : Success : ${cTime.get(i)} : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
+            if (cSkipped.get(i)) {
+              skipReport += `Test result : Skipped : ${cTime.get(i)} : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
+            } else {
+              passReport += `Test result : Success : ${cTime.get(i)} : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
+            }
           } else {
             failed = true;
             failReport += `Test result : Failed : ${cTime.get(i)} : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
           }
         }
-        resolve({failReport, passReport, failed});
+        resolve({failReport, skipReport, passReport, failed});
       }).catch((e: any) => reject(e));
     });
   }, targetPackage);
   // @ts-ignore
   console.log(r.passReport);
   // @ts-ignore
+  console.log(r.skipReport);
+  // @ts-ignore
   expect(r.failed).checkOutput(false, r.failReport);
-}, 3600000);
+}, 7200000);

package/src/autostart/calculations.ts

@@ -0,0 +1,37 @@
+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,
+): number {
+  const saltRowIndex = saltNames.indexOf(saltCol.get(i));
+  return (
+    saltRowIndex == -1 || molWeightCol.get(saltRowIndex) == DG.FLOAT_NULL || equivalentsCol.get(i) == DG.INT_NULL
+  ) ?
+    DG.FLOAT_NULL :
+    molWeightCol.get(saltRowIndex) * equivalentsCol.get(i);
+}
+
+export function saltMolWeigth(saltNamesList: string[], saltCol: DG.Column, molWeightCol: DG.Column, i: number): number {
+  const saltRowIndex = saltNamesList.indexOf(saltCol.get(i));
+  return (saltRowIndex == -1) ? DG.FLOAT_NULL : molWeightCol.get(saltRowIndex);
+}
+
+export function batchMolWeight(compoundMolWeightCol: DG.Column, saltMassCol: DG.Column, i: number): number {
+  return (compoundMolWeightCol.getString(i) == '' || saltMassCol.getString(i) == '') ?
+    DG.FLOAT_NULL :
+    compoundMolWeightCol.get(i) + saltMassCol.get(i);
+}
+
+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;
+  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;
+}

package/src/autostart/constants.ts

@@ -0,0 +1,49 @@
+export const SEQUENCE_TYPES = {
+  SENSE_STRAND: 'SS',
+  ANTISENSE_STRAND: 'AS',
+  DUPLEX: 'Duplex',
+  TRIPLEX: 'Triplex',
+  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',
+  TYPE: 'Type',
+  CHEMISTRY_NAME: 'Chemistry Name',
+  INTERNAL_COMPOUND_ID: 'Internal compound ID',
+  IDP: 'IDP',
+  SEQUENCE: 'Sequence',
+  COMPOUND_NAME: 'Compound Name',
+  COMPOUND_COMMENTS: 'Compound Comments',
+  SALT: 'Salt',
+  EQUIVALENTS: 'Equivalents',
+  PURITY: 'Purity',
+  COMPOUND_MOL_WEIGHT: 'Cpd MW',
+  SALT_MOL_WEIGHT: 'Salt MW',
+  SALT_MASS: 'Salt mass',
+  BATCH_MOL_WEIGHT: 'Batch MW',
+  SOURCE: 'Source',
+  ICD: 'ICD',
+  OWNER: 'Owner',
+};
+
+export const GENERATED_COL_NAMES = [
+  COL_NAMES.COMPOUND_NAME,
+  COL_NAMES.COMPOUND_COMMENTS,
+  COL_NAMES.COMPOUND_MOL_WEIGHT,
+  COL_NAMES.SALT_MASS,
+  COL_NAMES.BATCH_MOL_WEIGHT,
+];