@datagrok/bio 1.5.7 → 1.5.8

package/src/monomer-library.ts

@@ -0,0 +1,199 @@
+export type MonomerEntry = {
+  mol: string,
+  type: string,
+  analogueCode: string,
+  linkages: { [link: string]: { atomNumber: number, type: string } }
+};
+export type MonomerEntries = { [name: string]: MonomerEntry };
+export type LinkData = { [link: string]: { atomNumber: number, type: string } };
+
+/** HELM associated sdf libraries with monomer processing*/
+export class MonomerLibrary {
+  static libName = 'monomerLibrary';
+
+  private monomerFields: string[] = [
+    'molecule', 'MonomerType', 'MonomerNaturalAnalogCode', 'MonomerName', 'MonomerCode', 'MonomerCaps', 'BranchMonomer',
+  ];
+
+  private library: MonomerEntries = {};
+
+  private monomers: string[] = [];
+
+  constructor(sdf: string) {
+    const sdfReader = new SDFReader();
+    const data = sdfReader.getColls(sdf);
+    this.monomerFields.forEach((f) => {
+      if (!(f in data))
+        throw new Error(`Monomer library was not compiled: ${f} field is absent in provided file`);
+
+      if (data[f].length != data.molecule.length)
+        throw new Error(`Monomer library was not compiled: ${f} field is not presented for each monomer`);
+    });
+
+    for (let i = 0; i < data.molecule.length; i++) {
+      const linkData = this.getLinkData(data.molecule[i], data.MonomerCaps[i], data.MonomerName[i]);
+      const entry = {
+        mol: data.molecule[i],
+        type: 'Peptide',
+        code: data.MonomerCode[i],
+        analogueCode: data.MonomerNaturalAnalogCode[i],
+        linkages: linkData,
+      };
+
+      const name = data.MonomerCode[i] !== '.' ? data.MonomerCode[i] : data.MonomerName[i];
+      this.library[name] = entry;
+      this.monomers.push(name);
+    }
+  }
+
+  /** getting full monomer information from monomer library
+   * @param {string} name
+   * @return {MonomerEntry}
+   */
+  public getMonomerEntry(name: string): MonomerEntry {
+    if (!this.monomers.includes(name))
+      throw new Error(`Monomer library do not contain ${name} monomer`);
+
+    return this.library[name];
+  }
+
+  /** getting mol as string for monomer
+   * @param {string} name
+   * @return {string}
+   */
+  public getMonomerMol(name: string): string {
+    if (!this.monomers.includes(name))
+      throw new Error(`Monomer library do not contain ${name} monomer`);
+
+
+    const entry = this.library[name];
+    let monomerMol = entry.mol.replace(/M  RGP  .+\n/, '');
+
+    //order matters
+    const links = Object.keys(entry.linkages);
+    for (const link of links)
+      monomerMol = monomerMol.replace('R#', entry.linkages[link].type + ' ');
+
+
+    return monomerMol;
+  }
+
+  /** getting the list of the minomers available in library*/
+  get monomerNames(): string[] {
+    return this.monomers;
+  }
+
+  static get id(): string {
+    return MonomerLibrary.libName;
+  }
+
+  private getLinkData(mol: string, caps: string, name: string): LinkData {
+    const rawData = mol.match(/M  RGP  .+/);
+    if (rawData === null)
+      throw new Error(`Monomer library was not compiled: ${name} entry has no RGP`);
+
+    const types: { [code: string]: string } = {};
+    caps.split('\n')?.forEach((e) => {
+      types[e.match(/\d+/)![0]] = e.match(/(?<=\])\w+/)![0];
+    });
+
+    const data = rawData[0].replace('M  RGP  ', '').split(/\s+/);
+    const res: LinkData = {};
+    for (let i = 0; i < parseInt(data[0]); i++) {
+      const code = parseInt(data[2 * i + 2]);
+      let type = '';
+      switch (code) {
+      case 1:
+        type = 'N-terminal';
+        break;
+      case 2:
+        type = 'C-terminal';
+        break;
+      case 3:
+        type = 'branch';
+        break;
+      default:
+        break;
+      }
+      res[type] = {atomNumber: parseInt(data[2 * i + 1]), type: types[code]};
+    }
+
+    return res;
+  }
+}
+
+//TODO: merge with Chem version
+class SDFReader {
+  dataColls: { [_: string]: string [] };
+
+  constructor() {
+    this.dataColls = {'molecule': []};
+  }
+
+  getColls(content: string): { [_: string]: string[] } {
+    this.read(content);
+    return this.dataColls;
+  }
+
+  read(content: string): void {
+    content = content.replaceAll('\r', ''); //equalize old and new sdf standards
+    let startIndex = content.indexOf('$$$$', 0);
+    this.parse(content, 0, startIndex, (name: string, val: string): void => { // TODO: type
+      this.dataColls[name] = [];
+      this.dataColls[name].push(val);
+    });
+    startIndex += 5;
+    while (startIndex > -1 && startIndex < content.length)
+      startIndex = this.readNext(content, startIndex);
+  }
+
+  readNext(content: string, startIndex: number): number {
+    const nextStartIndex = content.indexOf('$$$$', startIndex);
+    if (nextStartIndex === -1) {
+      return -1;
+    } else {
+      this.parse(content, startIndex, nextStartIndex,
+        (name: string, val: string): void => {
+          this.dataColls[name].push(val);
+        });
+    }
+
+    if (nextStartIndex > -1)
+      return nextStartIndex + 5;
+
+
+    return nextStartIndex;
+  }
+
+  parse(content: string, start: number, end: number, handler: (name: string, val: string) => void): void {
+    const molEnd = +content.indexOf('M  END\n', start) + 7;
+    let localEnd = start;
+    this.dataColls['molecule'].push(content.substring(start, molEnd));
+
+    start = molEnd;
+    while (localEnd < end) {
+      start = content.indexOf('> <', localEnd);
+      if (start === -1)
+        return;
+
+
+      start += 3;
+      localEnd = content.indexOf('>\n', start);
+      if (localEnd === -1)
+        return;
+
+
+      const propertyName = content.substring(start, localEnd);
+      start = localEnd + 2;
+
+      localEnd = content.indexOf('\n', start);
+      if (localEnd === -1)
+        localEnd = end;
+      else if (content[localEnd + 1] != '\n')
+        localEnd = content.indexOf('\n', localEnd + 1);
+
+      handler(propertyName, content.substring(start, localEnd));
+      localEnd += 2;
+    }
+  }
+}

package/src/package-test.ts

@@ -8,6 +8,8 @@ import './tests/detectors-test';
 import './tests/msa-tests';
 import './tests/sequence-space-test';
 import './tests/activity-cliffs-tests';
+import './tests/splitter-test';
+import './tests/renderer-test';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -16,8 +16,28 @@ 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 {getMolfilesFromSeq, HELM_CORE_LIB_FILENAME} from './utils/utils';
 import {getMacroMol} from './utils/atomic-works';
+import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
+
+//tags: init
+export async function initBio(): Promise<void> {
+  // apparently HELMWebEditor requires dojo to be initialized first
+  return new Promise((resolve, reject) => {
+    // @ts-ignore
+    dojo.ready(function() { resolve(null); });
+  });
+}
+
+
+//name: macromoleculeSequenceCellRenderer
+//tags: cellRenderer
+//meta.cellType: Macromolecule
+//output: grid_cell_renderer result
+export function macromoleculeSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
+  return new MacromoleculeSequenceCellRenderer();
+}
+
 
 //name: sequenceAlignment
 //input: string alignType {choices: ['Local alignment', 'Global alignment']}
@@ -109,21 +129,21 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
   }
 };
 
-//top-menu: Bio | Molfiles From HELM...
-//name: Molfiles From HELM
+//top-menu: Bio | To Atomic Level...
+//name: To Atomic Level
 //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> {
+export async function toAtomicLevel(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));
+  const monomersLibObject: any[] = JSON.parse(monomersLibFile);
+  const atomicCodes = getMolfilesFromSeq(sequence, monomersLibObject);
+  const result = await getMacroMol(atomicCodes!);
+
+  const col = DG.Column.fromStrings('regenerated', result);
+  col.semType = DG.SEMTYPE.MOLECULE;
+  col.tags[DG.TAGS.UNITS] = 'molblock';
+  df.columns.add(col);
 }
 
 
@@ -131,9 +151,17 @@ export async function molfilesFromHELM(df: DG.DataFrame, sequence: DG.Column): P
 //name: MSA
 //input: dataframe table
 //input: column sequence { semType: Macromolecule }
-export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.Column): Promise<void> {
+//output: column result
+export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.Column): Promise<DG.Column> {
   const msaCol = await runKalign(col, false);
   table.columns.add(msaCol);
+
+  // This call is required to enable cell renderer activation
+  await grok.data.detectSemanticTypes(table);
+
+  // const tv: DG.TableView = grok.shell.tv;
+  // tv.grid.invalidate();
+  return msaCol;
 }
 
 //name: Composition Analysis

package/src/tests/convert-test.ts

@@ -1,31 +1,152 @@
-import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
+import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
 
 import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import {ConverterFunc, DfReaderFunc} from './types';
+import {NOTATION, NotationConverter} from '../utils/notation-converter';
+
 // import {mmSemType} from '../const';
 // import {importFasta} from '../package';
 
 category('converters', () => {
-//   test('a', async () => {await _a();});
-//   test('b', async () => {await _b();});
-  test('testFastaToSeparator', async () => { await _testFastaToSeparator(); });
-  test('testSeparatorToFasta', async () => { await _testSeparatorToFasta(); });
-});
+  enum Samples {
+    fastaPt = 'fastaPt',
+    separatorPt = 'separatorPt',
+    helmPt = 'helmPt',
+
+    fastaDna = 'fastaDna',
+    separatorDna = 'separatorDna',
+    helmDna = 'helmDna',
+
+    fastaRna = 'fastaRna',
+    separatorRna = 'separatorRna',
+    helmRna = 'helmRna',
+  }
+
+  const _csvTxts: { [key: string]: string } = {
+    fastaPt: `seq
+FWPHEY
+YNRQWYV
+MKPSEYV
+`,
+    separatorPt: `seq
+F-W-P-H-E-Y
+Y-N-R-Q-W-Y-V
+M-K-P-S-E-Y-V
+`,
+    helmPt: `seq
+PEPTIDE1{F.W.P.H.E.Y}$$$
+PEPTIDE1{Y.N.R.Q.W.Y.V}$$$
+PEPTIDE1{M.K.P.S.E.Y.V}$$$
+`,
+    fastaDna: `seq
+ACGTC
+CAGTGT
+TTCAAC
+    `,
+    separatorDna: `seq
+A/C/G/T/C
+C/A/G/T/G/T
+T/T/C/A/A/C
+`,
+    helmDna: `seq
+DNA1{D(A)P.D(C)P.D(G)P.D(T)P.D(C)P}$$$
+DNA1{D(C)P.D(A)P.D(G)P.D(T)P.D(G)P.D(T)P}$$$
+DNA1{D(T)P.D(T)P.D(C)P.D(A)P.D(A)P.D(C)P}$$$
+`,
+    fastaRna: `seq
+ACGUC
+CAGUGU
+UUCAAC
+    `,
+    separatorRna: `seq
+A*C*G*U*C
+C*A*G*U*G*U
+U*U*C*A*A*C
+`,
+    helmRna: `seq
+RNA1{R(A)P.R(C)P.R(G)P.R(U)P.R(C)P}$$$
+RNA1{R(C)P.R(A)P.R(G)P.R(U)P.R(G)P.R(U)P}$$$
+RNA1{R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P}$$$
+`,
+  };
+
+  const _csvDfs: { [key: string]: Promise<DG.DataFrame> } = {};
+
+  /** Also detects semantic types
+   * @param {string} key
+   * @return {Promise<DG.DataFrame>}
+   */
+  function readCsv(key: string): Promise<DG.DataFrame> {
+    if (!(key in _csvDfs)) {
+      _csvDfs[key] = (async (): Promise<DG.DataFrame> => {
+        const csv: string = _csvTxts[key];
+        const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+        await grok.data.detectSemanticTypes(df);
+        return df;
+      })();
+    }
+    return _csvDfs[key];
+  };
+
+  function converter(tgtNotation: NOTATION, separator: string | null = null): ConverterFunc {
+    return function(srcCol: DG.Column): DG.Column {
+      const converter = new NotationConverter(srcCol);
+      const resCol = converter.convert(NOTATION.SEPARATOR, separator);
+      return resCol;
+    };
+  };
 
-// export async function _a() {
-//   expect(1, 1);
-// }
-// 
-// export async function _b() {
-//   expect(1, 2);
-// }
-
-export async function _testFastaToSeparator() {
-  expect(1, 1);
-}
-
-export async function _testSeparatorToFasta() {
-  expect(1, 2);
-}
+  async function _testConvert(srcKey: string, converter: ConverterFunc, tgtKey: string) {
+    const srcDf: DG.DataFrame = await readCsv(srcKey);
+    const srcCol: DG.Column = srcDf.col('seq')!;
+
+    const resCol: DG.Column = converter(srcCol);
+
+    const tgtDf: DG.DataFrame = await readCsv(tgtKey);
+    const tgtCol: DG.Column = tgtDf.col('seq')!;
+
+    expectArray(resCol.toList(), tgtCol.toList());
+  }
+
+  test('testFastaPtToSeparator', async () => {
+    await _testConvert(Samples.fastaPt, converter(NOTATION.SEPARATOR, '-'), Samples.separatorPt);
+  });
+  test('testFastaDnaToSeparator', async () => {
+    await _testConvert(Samples.fastaDna, converter(NOTATION.SEPARATOR, '/'), Samples.separatorDna);
+  });
+  test('testFastaRnaToSeparator', async () => {
+    await _testConvert(Samples.fastaRna, converter(NOTATION.SEPARATOR, '*'), Samples.separatorRna);
+  });
+
+  test('testFastaPtToHelm', async () => {
+    await _testConvert(Samples.fastaPt, converter(NOTATION.HELM), Samples.helmPt);
+  });
+  test('testFastaDnaToHelm', async () => {
+    await _testConvert(Samples.fastaDna, converter(NOTATION.HELM), Samples.helmDna);
+  });
+  test('testFastaRnaToHelm', async () => {
+    await _testConvert(Samples.fastaDna, converter(NOTATION.HELM), Samples.helmRna);
+  });
+
+  test('testSeparatorPtToFasta', async () => {
+    await _testConvert(Samples.separatorPt, converter(NOTATION.FASTA), Samples.fastaPt);
+  });
+  test('testSeparatorDnaToFasta', async () => {
+    await _testConvert(Samples.separatorDna, converter(NOTATION.FASTA), Samples.fastaDna);
+  });
+  test('testSeparatorDnaToFasta', async () => {
+    await _testConvert(Samples.separatorRna, converter(NOTATION.FASTA), Samples.fastaRna);
+  });
+
+  test('testSeparatorPtToHelm', async () => {
+    await _testConvert(Samples.separatorRna, converter(NOTATION.HELM), Samples.helmPt);
+  });
+  test('testSeparatorDnaToHelm', async () => {
+    await _testConvert(Samples.separatorRna, converter(NOTATION.HELM), Samples.helmDna);
+  });
+  test('testSeparatorRnaToHelm', async () => {
+    await _testConvert(Samples.separatorRna, converter(NOTATION.HELM), Samples.helmRna);
+  });
+});