@datagrok/bio 1.5.4 → 1.5.7

package/package.json

@@ -2,7 +2,7 @@
   "name": "@datagrok/bio",
   "beta": false,
   "friendlyName": "Bio",
-  "version": "1.5.4",
+  "version": "1.5.7",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -11,14 +11,15 @@
   },
   "dependencies": {
     "@biowasm/aioli": ">=2.4.0",
-    "@datagrok-libraries/bio": "^2.3.1",
+    "@datagrok-libraries/bio": "^2.4.1",
     "@datagrok-libraries/utils": "^1.0.0",
-    "@datagrok-libraries/ml": "^2.0.8",
+    "@datagrok-libraries/ml": "^2.0.9",
     "cash-dom": "latest",
     "datagrok-api": "^1.4.12",
     "dayjs": "latest",
     "ts-loader": "^9.2.5",
-    "typescript": "^4.4.2"
+    "typescript": "^4.4.2",
+    "openchemlib": "6.0.1"
   },
   "devDependencies": {
     "@types/jest": "^27.0.0",

package/src/package.ts

@@ -16,6 +16,8 @@ import {getEmbeddingColsNames, sequenceSpace} from './utils/sequence-space';
 import {AvailableMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {sequenceGetSimilarities, drawTooltip} from './utils/sequence-activity-cliffs';
+import { getMolfilesFromSeq, HELM_CORE_LIB_FILENAME } from './utils/utils';
+import {getMacroMol} from './utils/atomic-works';
 
 //name: sequenceAlignment
 //input: string alignType {choices: ['Local alignment', 'Global alignment']}
@@ -50,7 +52,7 @@ export function vdRegionViewer() {
 //top-menu: Bio | Sequence Activity Cliffs...
 //name: Sequence Activity Cliffs
 //description: detect activity cliffs
-//input: dataframe df [Input data table]
+//input: dataframe table [Input data table]
 //input: column sequence {semType: Macromolecule}
 //input: column activities
 //input: double similarity = 80 [Similarity cutoff]
@@ -66,6 +68,7 @@ export async function activityCliffs(df: DG.DataFrame, sequence: DG.Column, acti
     df,
     sequence,
     axesNames,
+    'Activity cliffs',
     activities,
     similarity,
     'Levenshtein',
@@ -101,11 +104,29 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
   if (plotEmbeddings) {
     for (const v of grok.shell.views) {
       if (v.name === table.name)
-        (v as DG.TableView).scatterPlot({x: embedColsNames[0], y: embedColsNames[1]});
+        (v as DG.TableView).scatterPlot({x: embedColsNames[0], y: embedColsNames[1], title: 'Sequence space'});
     }
   }
 };
 
+//top-menu: Bio | Molfiles From HELM...
+//name: Molfiles From HELM
+//description: returns molfiles for each monomer from HELM library
+//input: dataframe df [Input data table]
+//input: column sequence {semType: Macromolecule}
+export async function molfilesFromHELM(df: DG.DataFrame, sequence: DG.Column): Promise<void> {
+  const monomersLibFile = await _package.files.readAsText(HELM_CORE_LIB_FILENAME);
+  const monomersLibDf = DG.DataFrame.fromJson(monomersLibFile);
+  const atomicCodes = getMolfilesFromSeq(sequence, monomersLibDf);
+
+  let result: string[] = [];
+  for(let i = 0; i < atomicCodes!.length; i++)
+    result.push(getMacroMol(atomicCodes![i]));
+  
+  df.columns.add(DG.Column.fromStrings('regenerated', result));
+}
+
+
 //top-menu: Bio | MSA...
 //name: MSA
 //input: dataframe table

package/src/tests/activity-cliffs-tests.ts

@@ -26,6 +26,7 @@ category('activityCliffs', async () => {
       actCliffsDf,
       actCliffsDf.col('MSA')!,
       axesNames,
+      'Activity cliffs',
       actCliffsDf.col('Activity')!,
       50,
       'Levenshtein',

package/src/tests/detectors-test.ts

@@ -94,6 +94,7 @@ MWRSWY-CKHP
     msaComplex = 'MsaComplex',
     idCsv = 'IdCsv',
     sarSmallCsv = 'SarSmallCsv',
+    HelmCsv = 'HelmCsv',
   }
 
   const samples: { [key: string]: string } = {
@@ -102,6 +103,7 @@ MWRSWY-CKHP
     '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',
   };
 
   const _samplesDfs: { [key: string]: Promise<DG.DataFrame> } = {};
@@ -194,6 +196,14 @@ MWRSWY-CKHP
   test('samplesSarSmallCsvNegativeSmiles', async () => {
     await _testNeg(readSamplesCsv(Samples.sarSmallCsv), 'smiles');
   });
+
+  test('samplesHelmCsvHELM', async () => {
+    await _testPos(readSamplesCsv(Samples.HelmCsv), 'HELM', 'HELM', null);
+  });
+
+  test('samplesHelmCsvNegativeActivity', async () => {
+    await _testNeg(readSamplesCsv(Samples.HelmCsv), 'Activity');
+  });
 });
 
 export async function _testNeg(readDf: DfReaderFunc, colName: string) {
@@ -203,7 +213,7 @@ export async function _testNeg(readDf: DfReaderFunc, colName: string) {
   expect(col.semType === DG.SEMTYPE.MACROMOLECULE, false);
 }
 
-export async function _testPos(readDf: DfReaderFunc, colName: string, units: string, separator: string) {
+export async function _testPos(readDf: DfReaderFunc, colName: string, units: string, separator: string | null = null) {
   const df: DG.DataFrame = await readDf();
 
   const col: DG.Column = df.col(colName)!;

package/src/utils/atomic-works.ts

@@ -0,0 +1,252 @@
+import * as OCL from 'openchemlib/full.js';
+
+export function getMacroMol(molBlocks: string[]): string {
+  for (let i = 0; i < molBlocks.length; i++)
+    molBlocks[i] = rotateBackboneV3000(molBlocks[i]);
+
+  return linkV3000(molBlocks);
+}
+
+function rotateBackboneV3000(molecule: string): string {
+  let molBlock = OCL.Molecule.fromMolfile(molecule).toMolfileV3();
+  const coordinates = extractAtomDataV3000(molBlock);
+  const natom = coordinates.atomIndex.length;
+
+  const indexFivePrime = coordinates.atomIndex.indexOf(1);
+  const indexThreePrime = coordinates.atomIndex.indexOf(natom);
+
+  const xCenter = (coordinates.x[indexThreePrime] + coordinates.x[indexFivePrime])/2;
+  const yCenter = (coordinates.y[indexThreePrime] + coordinates.y[indexFivePrime])/2;
+
+  //place to center
+  for (let i = 0; i < natom; i++) {
+    coordinates.x[i] -= xCenter;
+    coordinates.y[i] -= yCenter;
+  }
+
+  let angle = 0;
+  if (coordinates.x[indexFivePrime] == 0)
+    angle = coordinates.y[indexFivePrime] > coordinates.y[indexThreePrime] ? Math.PI/2 : 3*Math.PI/2;
+  else if (coordinates.y[indexFivePrime] == 0)
+    angle = coordinates.x[indexFivePrime] > coordinates.x[indexThreePrime] ? Math.PI : 0;
+  else {
+    const derivative = coordinates.y[indexFivePrime]/coordinates.x[indexFivePrime];
+    angle = derivative > 0 ? Math.PI - Math.atan(derivative) : Math.atan(derivative);
+  }
+
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+
+  for (let i = 0; i < natom; i++) {
+    const xAdd = coordinates.x[i];
+    coordinates.x[i] = xAdd*cos - coordinates.y[i]*sin;
+    coordinates.y[i] = xAdd*sin + coordinates.y[i]*cos;
+  }
+
+  //place to right
+  const xShift = coordinates.x[indexFivePrime];
+  for (let i = 0; i < natom; i++)
+    coordinates.x[i] -= xShift;
+
+  //rewrite molBlock
+  let index = molBlock.indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
+  index = molBlock.indexOf('\n', index);
+  let indexEnd = index;
+  for (let i = 0; i < natom; i++) {
+    index = molBlock.indexOf('V30', index) + 4;
+    index = molBlock.indexOf(' ', index) + 1;
+    index = molBlock.indexOf(' ', index) + 1;
+    indexEnd = molBlock.indexOf(' ', index) + 1;
+    indexEnd = molBlock.indexOf(' ', indexEnd);
+
+    molBlock = molBlock.slice(0, index) +
+      coordinates.x[i] + ' ' + coordinates.y[i] +
+      molBlock.slice(indexEnd);
+
+    index = molBlock.indexOf('\n', index) + 1;
+  }
+
+  return molBlock;
+}
+
+function extractAtomDataV3000(molBlock: string) {
+  const numbers = extractAtomsBondsNumbersV3000(molBlock);
+  let index = molBlock.indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
+  index = molBlock.indexOf('\n', index);
+  let indexEnd = index;
+
+  const indexes: number[] = Array(numbers.natom);
+  const types: string[] = Array(numbers.natom);
+  const x: number[] = Array(numbers.natom);
+  const y: number[] = Array(numbers.natom);
+
+  for (let i = 0; i < numbers.natom; i++) {
+    index = molBlock.indexOf('V30', index) + 4;
+    indexEnd = molBlock.indexOf(' ', index);
+    indexes[i] = parseInt(molBlock.substring(index, indexEnd));
+
+    index = indexEnd + 1;
+    indexEnd = molBlock.indexOf(' ', index);
+    types[i] = molBlock.substring(index, indexEnd);
+
+    index = indexEnd + 1;
+    indexEnd = molBlock.indexOf(' ', index);
+    x[i] = parseFloat(molBlock.substring(index, indexEnd));
+
+    index = indexEnd + 1;
+    indexEnd = molBlock.indexOf(' ', index);
+    y[i] = parseFloat(molBlock.substring(index, indexEnd));
+
+    index = molBlock.indexOf('\n', index) + 1;
+  }
+
+  return {atomIndex: indexes, atomType: types, x: x, y: y};
+}
+
+function linkV3000(molBlocks: string[]): string {
+  let macroMolBlock = '\nDatagrok macromolecule handler\n\n';
+  macroMolBlock += '  0  0  0  0  0  0            999 V3000\n';
+  macroMolBlock += 'M  V30 BEGIN CTAB\n';
+  let atomBlock = '';
+  let bondBlock = '';
+  let collectionBlock = '';
+  const collection: number [] = [];
+  let natom = 0;
+  let nbond = 0;
+  let xShift = 0;
+
+  for (let i = 0; i < molBlocks.length; i++) {
+    molBlocks[i] = molBlocks[i].replaceAll('(-\nM  V30 ', '(')
+      .replaceAll('-\nM  V30 ', '').replaceAll(' )', ')');
+    const numbers = extractAtomsBondsNumbersV3000(molBlocks[i]);
+    const coordinates = extractAtomDataV3000(molBlocks[i]);
+
+    let indexAtoms = molBlocks[i].indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
+    indexAtoms = molBlocks[i].indexOf('\n', indexAtoms);
+    let index = indexAtoms;
+    let indexEnd = indexAtoms;
+
+    for (let j = 0; j < numbers.natom; j++) {
+      if (coordinates.atomIndex[j] != 1 || i == 0) {
+        //rewrite atom number
+        index = molBlocks[i].indexOf('V30', index) + 4;
+        indexEnd = molBlocks[i].indexOf(' ', index);
+        const atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;
+        molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);
+
+        //rewrite coordinates
+        index = molBlocks[i].indexOf(' ', index) + 1;
+        index = molBlocks[i].indexOf(' ', index) + 1;
+        indexEnd = molBlocks[i].indexOf(' ', index);
+
+        const totalShift = xShift - coordinates.x[0];
+        let coordinate = Math.round(10000*(parseFloat(molBlocks[i].substring(index, indexEnd)) + totalShift))/10000;
+        molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);
+
+        index = molBlocks[i].indexOf(' ', index) + 1;
+        indexEnd = molBlocks[i].indexOf(' ', index);
+        coordinate = Math.round(10000*(parseFloat(molBlocks[i].substring(index, indexEnd))))/10000;
+        molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);
+
+        index = molBlocks[i].indexOf('\n', index) + 1;
+      } else {
+        index = molBlocks[i].indexOf('M  V30', index) - 1;
+        indexEnd = molBlocks[i].indexOf('\n', index + 1);
+        molBlocks[i] = molBlocks[i].slice(0, index) + molBlocks[i].slice(indexEnd);
+      }
+    }
+
+    const indexAtomsEnd = molBlocks[i].indexOf('M  V30 END ATOM');
+    atomBlock += molBlocks[i].substring(indexAtoms + 1, indexAtomsEnd);
+
+    let indexBonds = molBlocks[i].indexOf('M  V30 BEGIN BOND'); // V3000 index for bonds
+    indexBonds = molBlocks[i].indexOf('\n', indexBonds);
+    index = indexBonds;
+    indexEnd = indexBonds;
+
+    for (let j = 0; j < numbers.nbond; j++) {
+      //rewrite bond number
+      index = molBlocks[i].indexOf('V30', index) + 4;
+      indexEnd = molBlocks[i].indexOf(' ', index);
+      const bondNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + nbond;
+      molBlocks[i] = molBlocks[i].slice(0, index) + bondNumber + molBlocks[i].slice(indexEnd);
+
+      //rewrite atom pair in bond
+      index = molBlocks[i].indexOf(' ', index) + 1;
+      index = molBlocks[i].indexOf(' ', index) + 1;
+      indexEnd = molBlocks[i].indexOf(' ', index);
+      let atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;
+      molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);
+      index = molBlocks[i].indexOf(' ', index) + 1;
+      indexEnd = Math.min(molBlocks[i].indexOf('\n', index), molBlocks[i].indexOf(' ', index));
+      atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;
+      molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);
+
+      index = molBlocks[i].indexOf('\n', index) + 1;
+    }
+
+    const indexBondEnd = molBlocks[i].indexOf('M  V30 END BOND');
+    bondBlock += molBlocks[i].substring(indexBonds + 1, indexBondEnd);
+
+    let indexCollection = molBlocks[i].indexOf('M  V30 MDLV30/STEABS ATOMS=('); // V3000 index for collections
+
+    while (indexCollection != -1) {
+      indexCollection += 28;
+      const collectionEnd = molBlocks[i].indexOf(')', indexCollection);
+      const collectionEntries = molBlocks[i].substring(indexCollection, collectionEnd).split(' ').slice(1);
+      collectionEntries.forEach((e) => {
+        collection.push(parseInt(e) + natom);
+      });
+      indexCollection = collectionEnd;
+      indexCollection = molBlocks[i].indexOf('M  V30 MDLV30/STEABS ATOMS=(', indexCollection);
+    }
+
+    natom += numbers.natom - 1;
+    nbond += numbers.nbond;
+    xShift += coordinates.x[numbers.natom - 1] - coordinates.x[0];
+  }
+
+  const entries = 4;
+  const collNumber = Math.ceil(collection.length / entries);
+  collectionBlock += 'M  V30 MDLV30/STEABS ATOMS=(' + collection.length + ' -\n';
+  for (let i = 0; i < collNumber; i++) {
+    collectionBlock += 'M  V30 ';
+    const entriesCurrent = i + 1 == collNumber ? collection.length - (collNumber - 1)*entries : entries;
+    for (let j = 0; j < entriesCurrent; j++) {
+      collectionBlock += (j + 1 == entriesCurrent) ?
+        (i == collNumber - 1 ? collection[entries*i + j] + ')\n' : collection[entries*i + j] + ' -\n') :
+        collection[entries*i + j] + ' ';
+    }
+  }
+
+  //generate file
+  natom++;
+  macroMolBlock += 'M  V30 COUNTS ' + natom + ' ' + nbond + ' 0 0 0\n';
+  macroMolBlock += 'M  V30 BEGIN ATOM\n';
+  macroMolBlock += atomBlock;
+  macroMolBlock += 'M  V30 END ATOM\n';
+  macroMolBlock += 'M  V30 BEGIN BOND\n';
+  macroMolBlock += bondBlock;
+  macroMolBlock += 'M  V30 END BOND\n';
+  macroMolBlock += 'M  V30 BEGIN COLLECTION\n';
+  macroMolBlock += collectionBlock;
+  macroMolBlock += 'M  V30 END COLLECTION\n';
+  macroMolBlock += 'M  V30 END CTAB\n';
+  macroMolBlock += 'M  END\n';
+
+  return macroMolBlock;
+}
+
+function extractAtomsBondsNumbersV3000(molBlock: string): {natom: number, nbond: number} {
+  molBlock = molBlock.replaceAll('\r', ''); //equalize old and new sdf standards
+  let index = molBlock.indexOf('COUNTS') + 7; // V3000 index for atoms and bonds number
+  let indexEnd = molBlock.indexOf(' ', index);
+
+  const atomsNumber = parseInt(molBlock.substring(index, indexEnd));
+  index = indexEnd + 1;
+  indexEnd = molBlock.indexOf(' ', index);
+  const bondsNumber = parseInt(molBlock.substring(index, indexEnd));
+
+  return {natom: atomsNumber, nbond: bondsNumber};
+}
+

package/src/utils/utils.ts

@@ -0,0 +1,40 @@
+import * as DG from 'datagrok-api/dg';
+import { WebLogo, SplitterFunc } from '@datagrok-libraries/bio/src/viewers/web-logo';
+import * as grok from 'datagrok-api/grok';
+
+export const HELM_CORE_LIB_MONOMER_COL = 'symbol';
+export const HELM_CORE_LIB_MOLFILE_COL = 'molfile';
+export const HELM_CORE_LIB_FILENAME = '/samples/HELMCoreLibrary.json';
+
+export function getMolfilesFromSeq(col: DG.Column, monomersLib: DG.DataFrame): string[][] | null {
+    const units = col.tags[DG.TAGS.UNITS];
+    const sep = col.getTag('separator');
+    const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, sep);
+    const monomersDict = createMomomersMolDict(monomersLib);
+    const molFiles = [];
+    for (let i = 0; i < col.length; ++i) {
+        const monomers = splitterFunc(col.get(i));
+        const molFilesForSeq = [];
+        for (let j = 0; j < monomers.length; ++j) {
+            if (monomers[j]) {
+                if (!monomersDict[monomers[j]]) {
+                    grok.shell.warning(`Monomer ${monomers[j]} is missing in HELM library. Structure cannot be created`);
+                    return null;
+                }
+                molFilesForSeq.push(monomersDict[monomers[j]])
+            }
+        }
+        molFiles.push(molFilesForSeq);
+    }
+    return molFiles;
+  }
+
+export function createMomomersMolDict(lib: DG.DataFrame): {[key: string]: string} {
+    const dict: {[key: string]: string} = {};
+    const monmersCol = lib.col(HELM_CORE_LIB_MONOMER_COL);
+    const molCol = lib.col(HELM_CORE_LIB_MOLFILE_COL);
+    for (let i = 0; i < lib.rowCount; ++i) {
+        dict[monmersCol!.get(i)] = molCol!.get(i);
+    }
+    return dict;
+}

package/tsconfig.json

@@ -6,7 +6,7 @@
       // "incremental": true,                         /* Enable incremental compilation */
       "target": "es6",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
       "module": "es2020",                             /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
-      "lib": ["es2020", "dom"],                       /* Specify library files to be included in the compilation. */
+      "lib": ["es2020", "dom", "ES2021.String"],                       /* Specify library files to be included in the compilation. */
       // "allowJs": true,                             /* Allow javascript files to be compiled. */
       // "checkJs": true,                             /* Report errors in .js files. */
       // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */