@datagrok/sequence-translator 1.4.3 → 1.4.4

package/files/polytool-rules/rules_example.json

@@ -27,9 +27,9 @@
     "type": "reaction",
     "code": "3",
     "monomericSubstitution": {
-      "firstMonomer": "aG",
-      "secondMonomer": "azG",
-      "reaction": "[H:1]NC(C([OH:2])=O)c1cn(C(N[H:3])C([OH:4])=O)nn1",
+      "firstMonomer": "azG",
+      "secondMonomer": "aG",
+      "reaction": "[C:1]N=[N+]=[N-].[C:2]C#C>>[C:1]N1-N=NC=C1[C:2]",
       "name": "GGaz"
     }
   },

package/files/samples/cyclized.csv

@@ -4,4 +4,5 @@ n,seqs
 3,R-F-C(1)-T-G-H-F-Y-P-C(1)
 4,C(1)-T-G-H-F-H-P-C(1)
 5,R-F-D(2)-T-G-H-F-Y-P-NH2(2)
-6,R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI
+6,R-F-azG(3)-T-G-H-F-Y-P-aG(3)-meI
+7,R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "author": {
-    "name": "Alexey Choposky",
+    "name": "Alexey Chopovsky",
     "email": "achopovsky@datagrok.ai"
   },
   "description": "SequenceTranslator translates [oligonucleotide](https://en.wikipedia.org/wiki/Oligonucleotide) sequences between [different representations](https://github.com/datagrok-ai/public/tree/master/packages/SequenceTranslator#sequence-representations).",

package/src/polytool/pt-conversion.ts

@@ -1,10 +1,18 @@
-// import * as grok from 'datagrok-api/grok';
-// import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
 
-
-//import {ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {IMonomerLib, IMonomerLibBase, Monomer, MonomerLibData, RGroup} from '@datagrok-libraries/bio/src/types';
+import {RDModule, RDMol, RDReaction, MolList, RDReactionResult} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {HELM_REQUIRED_FIELD, HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 
 import {Rules, RuleLink, RuleReaction} from './pt-rules';
+import {InvalidReactionError, MonomerNotFoundError} from './types';
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+import {_package} from '../package';
 
 export const RULES_DIMER = '(#2)';
 export const RULES_HETERODIMER = '($2)';
@@ -32,7 +40,14 @@ export class Chain {
     const rawLinkages = fragmentation[1].split('|');
 
     const monomers = new Array<Array<string>>(rawFragments.length);
-    const linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[] = [];
+    const linkages: {
+      fChain: number,
+      sChain: number,
+      fMonomer: number,
+      sMonomer: number,
+      fR: number,
+      sR: number
+    }[] = [];
 
     //HELM parsing
     for (let i = 0; i < rawFragments.length; i++) {
@@ -71,7 +86,14 @@ export class Chain {
     const homodimerCode = rules.homodimerCode;
     const mainFragments: string[] = [];
 
-    const linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[] = [];
+    const linkages: {
+      fChain: number,
+      sChain: number,
+      fMonomer: number,
+      sMonomer: number,
+      fR: number,
+      sR: number
+    }[] = [];
 
     //NOTICE: this works only with simple single heterodimers
     const heterodimeric = heterodimerCode !== null ? sequence.split(`(${rules.heterodimerCode!})`) : '';
@@ -374,10 +396,155 @@ export class Chain {
 export function doPolyToolConvert(sequences: string[], rules: Rules): string[] {
   const helms = new Array<string>(sequences.length);
   for (let i = 0; i < sequences.length; i++) {
-    if (sequences[i] == null) { helms[i] = ''; } else {
-      const chain = Chain.fromNotation(sequences[i], rules);
-      helms[i] = chain.getHelm();
+    try {
+      if (sequences[i] == null) { helms[i] = ''; } else {
+        const chain = Chain.fromNotation(sequences[i], rules);
+        helms[i] = chain.getHelm();
+      }
+    } catch (err: any) {
+      const [errMsg, errStack] = errInfo(err);
+      _package.logger.error(errMsg, undefined, errStack);
+      helms[i] = '';
     }
   }
   return helms;
 }
+
+function getMonomersMolBlocks(monomer1: Monomer, monomer2: Monomer): [string, string] {
+  const mb1 = monomer1.molfile;
+  let mb2 = monomer2.molfile;
+  const addGroups = monomer1.rgroups.length;
+
+  //mol v2000 monomer
+  const rgpIdx = mb2.indexOf('M  RGP');
+  if (rgpIdx !== -1) {
+    const groupsCountStr = mb2.substring(rgpIdx + 6, rgpIdx + 9);
+    const groupsCount = Number(groupsCountStr);
+
+    for (let i = 0; i < groupsCount; i++) {
+      const start = rgpIdx + 9 + 4 + i * 8;
+      const end = rgpIdx + 9 + 8 + i * 8;
+      const rGroupSpecifier = mb2.substring(start, end);
+      const groupPosition = Number(rGroupSpecifier) + addGroups;
+      const digits = Math.floor(Math.log10(groupPosition) + 1);
+      const newSpecifier = ' '.repeat(4 - digits) + String(groupPosition);
+      mb2 = mb2.substring(0, start) + newSpecifier + mb2.substring(end, mb2.length);
+    }
+  }
+
+  //TODO: same for v3000 monomer
+
+  return [mb1, mb2];
+}
+
+function getSyntheticMolBlock(rdkit: RDModule, reaction: string,
+  mb1: string, mb2: string, monomerName: string): string {
+  let rxn: RDReaction | null = null;
+  let mols: MolList | null = null;
+  let mol1: RDMol | null = null;
+  let mol2: RDMol | null = null;
+  let rctns: RDReactionResult | null = null;
+  let molP: RDMol | null = null;
+  let molBlock = '';
+
+  try {
+    rxn = rdkit.get_rxn(reaction);
+    if (!rxn) throw new InvalidReactionError(reaction);
+    mols = new rdkit.MolList();
+    mol1 = rdkit.get_mol(mb1!);
+    mol2 = rdkit.get_mol(mb2!);
+    mols.append(mol1!);
+    mols.append(mol2!);
+
+    rctns = rxn.run_reactants(mols, 1);
+    //const size = rctns.size();
+    const element = rctns.get(0);
+
+    molP = element.next();
+    molBlock = molP?.get_molblock();//molP?.get_v3Kmolblock();//
+  } catch (err: any) {
+    const [errMsg, _errStack] = errInfo(err);
+    grok.shell.error(`Can not assemble monomer '${monomerName}': ${errMsg}.`);
+    throw err;
+  } finally {
+    rxn?.delete();
+    mols?.delete();
+    mol1?.delete();
+    mol2?.delete();
+    rctns?.delete();
+    molP?.delete();
+  }
+
+  return molBlock;
+}
+
+function getNewGroups(monomer1: Monomer, monomer2: Monomer): RGroup[] {
+  const groups = new Array<RGroup>(monomer1?.rgroups.length! + monomer2?.rgroups.length!);
+  const length1 = monomer1?.rgroups.length!;
+  const length2 = monomer2?.rgroups.length!;
+
+  for (let i = 0; i < length1; i++)
+    groups[i] = monomer1?.rgroups[i]!;
+
+  for (let i = 0; i < length2; i++) {
+    const rGroupSpecifier = monomer2?.rgroups[i]!.label.replace('R', '');
+    const groupPosition = Number(rGroupSpecifier) + length1;
+    const group: RGroup = {
+      //@ts-ignore
+      [HELM_RGROUP_FIELDS.CAP_GROUP_SMILES_UPPERCASE]: monomer2?.rgroups[i].capGroupSMILES.replace(rGroupSpecifier, String(groupPosition)),
+      [HELM_RGROUP_FIELDS.ALTERNATE_ID]: monomer2?.rgroups[i].alternateId.replace(rGroupSpecifier, String(groupPosition)),
+      [HELM_RGROUP_FIELDS.CAP_GROUP_NAME]: monomer2?.rgroups[i].capGroupName,
+      [HELM_RGROUP_FIELDS.LABEL]: monomer2?.rgroups[i].label.replace(rGroupSpecifier, String(groupPosition)),
+    };
+
+    groups[i + length1] = group;
+  }
+
+  return groups;
+}
+
+export function getNewMonomer(rdkit: RDModule, mLib: IMonomerLib, rule: RuleReaction): [string, Monomer] {
+  const reacSmarts = rule.reaction;
+  const monomerName = rule.name;
+
+  const monomer1 = mLib.getMonomer('PEPTIDE', rule.firstMonomer);
+  if (!monomer1) throw new MonomerNotFoundError('PEPTIDE', rule.firstMonomer);
+  const monomer2 = mLib.getMonomer('PEPTIDE', rule.secondMonomer);
+  if (!monomer2) throw new MonomerNotFoundError('PEPTIDE', rule.secondMonomer);
+
+  const [mb1, mb2] = getMonomersMolBlocks(monomer1!, monomer2!);
+  const molBlock = getSyntheticMolBlock(rdkit, reacSmarts, mb1, mb2, monomerName);
+  const groups: RGroup[] = getNewGroups(monomer1!, monomer2!);
+
+  const resMonomer: Monomer = {
+    [HELM_REQUIRED_FIELD.SYMBOL]: monomerName,
+    [HELM_REQUIRED_FIELD.NAME]: monomerName,
+    [HELM_REQUIRED_FIELD.MOLFILE]: molBlock,
+    [HELM_REQUIRED_FIELD.AUTHOR]: '',
+    [HELM_REQUIRED_FIELD.ID]: 0,
+    [HELM_REQUIRED_FIELD.RGROUPS]: groups,
+    [HELM_REQUIRED_FIELD.SMILES]: '',
+    [HELM_REQUIRED_FIELD.POLYMER_TYPE]: 'PEPTIDE',
+    [HELM_REQUIRED_FIELD.MONOMER_TYPE]: 'Backbone',
+    [HELM_REQUIRED_FIELD.CREATE_DATE]: null,
+  };
+
+  return [monomerName, resMonomer];
+}
+
+export async function getOverriddenLibrary(rules: Rules): Promise<IMonomerLibBase> {
+  const monomerLibHelper = await getMonomerLibHelper();
+  const systemMonomerLib = monomerLibHelper.getMonomerLib();
+
+  const rdkit = await getRdKitModule();
+  const argLib: { [symbol: string]: Monomer } = {};
+
+  for (let i = 0; i < rules.reactionRules.length; i++) {
+    const [name, monomer] = getNewMonomer(rdkit, systemMonomerLib, rules.reactionRules[i]);
+    argLib[name] = monomer;
+  }
+
+  const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: argLib};
+  const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData);
+  return overriddenMonomerLib;
+}

package/src/polytool/pt-dialog.ts

@@ -11,8 +11,8 @@ import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
-import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
-import {doPolyToolConvert} from './pt-conversion';
+import {getRules, RuleInputs, Rules, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {doPolyToolConvert, getOverriddenLibrary} from './pt-conversion';
 import {defaultErrorHandler} from '../utils/err-info';
 import {getLibrariesList} from './utils';
 import {getEnumerationChem, PT_CHEM_EXAMPLE} from './pt-enumeration-chem';
@@ -85,7 +85,7 @@ export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.D
     const chiralityEngineInput = ui.input.bool(PT_UI_USE_CHIRALITY, {value: false});
     let ruleFileList: string[];
     const ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json', {
-      onValueChanged: (value: string[]) => { ruleFileList = value;}
+      onValueChanged: (value: string[]) => { ruleFileList = value; }
     });
     const rulesHeader = ui.inlineText([PT_UI_RULES_USED]);
     ui.tooltip.bind(rulesHeader, 'Add or specify rules to use');
@@ -256,28 +256,11 @@ export async function polyToolConvert(
     if (generateHelm && table) table.columns.add(resHelmCol, true);
 
     const seqHelper: ISeqHelper = await getSeqHelper();
-    const toAtomicLevelRes = await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, /* highlight */ generateHelm);
+    const lib = await getOverriddenLibrary(rules);
+    const toAtomicLevelRes =
+      await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, /* highlight */ generateHelm, lib);
     const resMolCol = toAtomicLevelRes.molCol!;
 
-    // const rdkit = await grok.functions.call('Chem:getRdKitModule');
-    // for (let i = 0; i < rules.reactionRules.length; i++) {
-    //   const reacSmarts = rules.reactionRules[i].reaction;
-    //   const rxn = rdkit.get_rxn(reacSmarts);
-
-    //   for (let j = 0; j < resMolCol.length; j++) {
-    //     const mols = new rdkit.MolList();
-    //     const mol = rdkit.get_mol(resMolCol.get(j));
-    //     mols.append(mol!);
-    //     const rctns = rxn.run_reactants(mols, 1);
-    //     const size = rctns.size();
-    //     const element = rctns.get(0);
-    //     let molP: RDMol | null = null;
-    //     molP = element.next();
-    //     const molBlock = molP?.get_v3Kmolblock();
-    //     resMolCol.set(j, molBlock!);
-    //   }
-    // }
-
     resMolCol.name = getUnusedName(table, `molfile(${seqCol.name})`);
     resMolCol.semType = DG.SEMTYPE.MOLECULE;
     if (table) {

package/src/polytool/types.ts

@@ -2,6 +2,8 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
+import {PolymerType} from '@datagrok-libraries/bio/src/helm/types';
+
 export enum PolyToolEnumeratorTypes {
   Single = 'single',
   Matrix = 'matrix',
@@ -21,3 +23,19 @@ export type PolyToolEnumeratorParams = {
   keepOriginal?: boolean;
   trivialName?: boolean;
 }
+
+export class MonomerNotFoundError extends Error {
+  public type = 'MonomerNotFoundError';
+
+  constructor(polymerType: PolymerType, symbol: string, options?: ErrorOptions) {
+    super(`Monomer '${symbol}' of polymer type '${polymerType}' not found`, options);
+  }
+}
+
+export class InvalidReactionError extends Error {
+  public type = 'InvalidReactionError';
+
+  constructor(reaction: string, options?: ErrorOptions) {
+    super(`Invalid reaction '${reaction}'.`);
+  }
+}

package/src/tests/polytool-chain-from-notation-tests.ts

@@ -0,0 +1,45 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
+import {Chain} from '../polytool/pt-conversion';
+import {getRules} from '../polytool/pt-rules';
+
+category('PolyTool: Chain: fromNotation', () => {
+  const tests = {
+    'cyclized': {
+      src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI'},
+      tgt: {
+        monomerCount: [11], linkageCount: 1,
+        helm: 'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$',
+      },
+    },
+    'reaction1': {
+      src: {seq: 'R-F-azG(3)-T-G-H-F-Y-P-aG(3)-meI'},
+      tgt: {
+        monomerCount: [9, 1], linkageCount: 2,
+        helm: 'PEPTIDE1{R.F.[GGaz].T.G.H.F.Y.P}|PEPTIDE2{[meI]}$PEPTIDE1,PEPTIDE1,3:R3-9:R2|PEPTIDE1,PEPTIDE2,3:R4-1:R1$$$',
+      }
+    },
+    'reaction2': {
+      src: {seq: 'R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI'},
+      tgt: {
+        // TODO: Target test data requires clarification
+        monomerCount: [2, 8], linkageCount: 0,
+        helm: 'PEPTIDE1{R.F}|PEPTIDE2{T.G.H.F.Y.P.[GGaz].[meI]}$PEPTIDE1,PEPTIDE2,2:R2-7:R3|PEPTIDE2,PEPTIDE2,1:R1-7:R4,$$$',
+      }
+    }
+
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const resChain = Chain.fromNotation(testData.src.seq, rules);
+      expectArray(resChain.monomers.map((mL) => mL.length), testData.tgt.monomerCount);
+      expect(resChain.linkages.length, testData.tgt.linkageCount);
+      expect(resChain.getHelm(), testData.tgt.helm);
+    }, testName == 'reaction2' ? {skipReason: 'reverse reaction'} : undefined);
+  }
+});

package/src/tests/toAtomicLevel-tests.ts

@@ -15,6 +15,8 @@ import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
 import {_package} from '../package-test';
+import {getNewMonomer} from '../polytool/pt-conversion';
+import {getRules, RuleReaction} from '../polytool/pt-rules';
 
 category('toAtomicLevel', () => {
   let userLibSettings: UserLibSettings;
@@ -69,4 +71,27 @@ category('toAtomicLevel', () => {
       mol.delete();
     }
   });
+
+  test('getNewMonomer', async () => {
+    const rdKitModule = await getRdKitModule();
+    const systemMonomerLib = monomerLibHelper.getMonomerLib();
+
+    const rules = await getRules(['rules_example.json']);
+    const reactionRule = rules.reactionRules.find((r) => r.name == 'GGaz')!;
+
+    const [newSymbol, newMonomer] = getNewMonomer(rdKitModule, systemMonomerLib, reactionRule);
+    expect(newSymbol, reactionRule.name);
+
+    const mol = rdKitModule.get_mol(newMonomer.molfile);
+    try {
+      const molInchi = mol.get_inchi();
+      const molInchiKey = rdKitModule.get_inchikey_for_inchi(molInchi);
+      expect(mol.get_num_bonds(), 18);
+      expect(mol.get_num_atoms(), 18);
+      // TODO: Check inchi key for the new monomer molfile
+      // expect(molInchiKey, 'V2H10N2O3S-UHFFFAOYSA-N');
+    } finally {
+      mol.delete();
+    }
+  });
 });