@datagrok/sequence-translator 1.4.7 → 1.4.10

package/src/polytool/conversion/pt-misc.ts

@@ -0,0 +1,183 @@
+import * as grok from 'datagrok-api/grok';
+
+import wu from 'wu';
+import {PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {getMonomerLibHelper} 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 as REQ,
+  HELM_OPTIONAL_FIELDS as OPT, HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {Rules, RuleReaction} from '../pt-rules';
+import {InvalidReactionError, MonomerNotFoundError} from '../types';
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+
+/** Gets 0-based in-index (simple polymer) of out-index (continuous) {@link idx} */
+export function getInnerIdx(outIdx: number, monomers: string[][]): [number, number] {
+  // let prevSpCount = 0;
+  // for (let spI = 0; spI < monomers.length && idx >= (prevSpCount + monomers[spI].length); ++spI)
+  //   prevSpCount += monomers[spI].length;
+  // return idx - prevSpCount;
+  let inIdx = outIdx;
+  let spIdx: number;
+  for (spIdx = 0; spIdx < monomers.length && inIdx >= monomers[spIdx].length; ++spIdx)
+    inIdx -= monomers[spIdx].length;
+  return [inIdx, spIdx];
+}
+
+/** Gets 0-based out-index of 0-based in-index {@link inIdx} monomer of simple polymer {@link spIdx} */
+export function getOuterIdx(inIdx: number, spIdx: number, monomers: string[][]): number {
+  let outIdx = 0;
+  for (let i = 0; i < spIdx; ++i)
+    outIdx += monomers[i].length;
+  return outIdx + inIdx;
+}
+
+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 = {
+    [REQ.SYMBOL]: monomerName,
+    [REQ.NAME]: monomerName,
+    [REQ.MOLFILE]: molBlock,
+    [REQ.AUTHOR]: '',
+    [REQ.ID]: 0,
+    [REQ.RGROUPS]: groups,
+    [REQ.SMILES]: '',
+    [REQ.POLYMER_TYPE]: 'PEPTIDE',
+    [REQ.MONOMER_TYPE]: 'Backbone',
+    [REQ.CREATE_DATE]: null,
+
+    // // @ts-ignore
+    // lib: {source: 'Reaction'},
+  };
+
+  resMonomer[OPT.META] = Object.assign(resMonomer[OPT.META] ?? {},
+    {'colors': {'default': {line: '#2083D5', text: '#2083D5', background: '#F2F2F5'}}});
+
+  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,
+    'ST-PT-reactions.' + wu.repeat(1).map(() => Math.floor((Math.random() * 36))
+      .toString(36)).take(4).toArray().join(''));
+  return overriddenMonomerLib;
+}

package/src/polytool/pt-dialog.ts

@@ -7,25 +7,38 @@ import {Unsubscribable} from 'rxjs';
 
 import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {MmcrTemps} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
-import {buildMonomerHoverLink} from '@datagrok-libraries/bio/src/monomer-works/monomer-hover';
+import {addMonomerHoverLink, buildMonomerHoverLink} from '@datagrok-libraries/bio/src/monomer-works/monomer-hover';
 import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
-import {getRules, RuleInputs, Rules, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
-import {doPolyToolConvert, getOverriddenLibrary} from './pt-conversion';
+import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {doPolyToolConvert} from './conversion/pt-conversion';
+import {getOverriddenLibrary} from './conversion/pt-misc';
 import {defaultErrorHandler} from '../utils/err-info';
 import {getLibrariesList} from './utils';
 import {getEnumerationChem, PT_CHEM_EXAMPLE} from './pt-enumeration-chem';
 
 import {
   PT_ERROR_DATAFRAME, PT_UI_ADD_HELM, PT_UI_DIALOG_CONVERSION, PT_UI_DIALOG_ENUMERATION,
-  PT_UI_GET_HELM, PT_UI_RULES_USED, PT_UI_USE_CHIRALITY, PT_WARNING_COLUMN
+  PT_UI_GET_HELM, PT_UI_HIGHLIGHT_MONOMERS, PT_UI_RULES_USED, PT_UI_USE_CHIRALITY
 } from './const';
 
 import {_package} from '../package';
+import {IMonomerLibBase} from '@datagrok-libraries/bio/src/types/index';
+import {MonomerHoverLink} from '@datagrok-libraries/bio/src/monomer-works/utils';
+import {MonomerMap} from '@datagrok-libraries/bio/src/monomer-works/types';
+import {ISeqMonomer} from '@datagrok-libraries/bio/src/helm/types';
+import wu from 'wu';
+import {PolymerTypes} from '@datagrok-libraries/js-draw-lite/src/types/org';
+import {getMonomersDictFromLib} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
+import {monomerSeqToMolfile} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level-utils';
+import {LRUCache} from 'lru-cache';
+import {getMonomerHover, ISubstruct, setMonomerHover} from '@datagrok-libraries/chem-meta/src/types';
+import {getMolHighlight} from '@datagrok-libraries/bio/src/monomer-works/seq-to-molfile';
+import {ChemTags} from '@datagrok-libraries/chem-meta/src/consts';
 
 type PolyToolConvertSerialized = {
   generateHelm: boolean;
@@ -87,6 +100,7 @@ export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.D
     ui.tooltip.bind(generateHelmInput.root, PT_UI_ADD_HELM);
 
     const chiralityEngineInput = ui.input.bool(PT_UI_USE_CHIRALITY, {value: false});
+    const highlightMonomersInput = ui.input.bool(PT_UI_HIGHLIGHT_MONOMERS, {value: false});
     let ruleFileList: string[];
     const ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json', {
       onValueChanged: (value: string[]) => { ruleFileList = value; }
@@ -99,6 +113,7 @@ export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.D
       srcColInput,
       generateHelmInput,
       chiralityEngineInput,
+      highlightMonomersInput,
       rulesHeader,
       rulesForm
     ]);
@@ -129,7 +144,7 @@ export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.D
       /* applyInput */ (x: PolyToolConvertSerialized): void => {
         generateHelmInput.value = x.generateHelm;
         chiralityEngineInput.value = x.chiralityEngine;
-        ruleInputs.setActive(ruleFileList);
+        ruleInputs.setActive(x.rules);
       });
     return dialog;
   } catch (err: any) {
@@ -240,6 +255,8 @@ function dealGroups(col: DG.Column<string>): void {
     col.set(i, col.get(i)!.replaceAll('undefined', 'H'));
     col.set(i, col.get(i)!.replaceAll('Oh', 'O'));
     col.set(i, col.get(i)!.replaceAll('0.000000 3', '0.000000 0'));
+    col.set(i, col.get(i)!.replaceAll('?', 'O'));
+    col.set(i, col.get(i)!.replaceAll('0 3\n', '0 0\n'));
   }
 }
 
@@ -285,9 +302,121 @@ export async function polyToolConvert(
     }
 
     buildMonomerHoverLink(resHelmCol, resMolCol, lib, seqHelper, rdKitModule);
+    buildCyclizedMonomerHoverLink(seqCol, resHelmCol, resMolCol, lib, seqHelper, rdKitModule);
 
     return [resHelmCol, resMolCol];
   } finally {
     pi.close();
   }
 }
+
+function buildCyclizedMonomerHoverLink(
+  cyclizedCol: DG.Column<string>, seqCol: DG.Column<string>, molCol: DG.Column<string>,
+  monomerLib: IMonomerLibBase, seqHelper: ISeqHelper, rdKitModule: RDModule
+): MonomerHoverLink {
+  function buildMonomerMap(seqCol: DG.Column<string>, tableRowIdx: number): MonomerMap {
+    const seqSH = seqHelper.getSeqHandler(seqCol);
+    const seqSS = seqSH.getSplitted(tableRowIdx);
+    const biotype = seqSH.defaultBiotype;
+    const seqMList: ISeqMonomer[] = wu.count(0).take(seqSS.length)
+      .map((posIdx) => {
+        return {position: posIdx, symbol: seqSS.getCanonical(posIdx), biotype: biotype} as ISeqMonomer;
+      })
+      .toArray();
+
+    const alphabet = seqSH.alphabet as ALPHABET;
+    const polymerType = alphabet == ALPHABET.RNA || alphabet == ALPHABET.DNA ? PolymerTypes.RNA : PolymerTypes.PEPTIDE;
+    const monomersDict = getMonomersDictFromLib([seqMList], polymerType, alphabet, monomerLib, rdKitModule);
+    // Call seq-to-molfile worker core directly
+    const molWM = monomerSeqToMolfile(seqMList, monomersDict, alphabet, polymerType);
+    return molWM.monomers;
+  }
+
+  const monomerMapLruCache = new LRUCache<string, MonomerMap>({max: 100});
+
+  function getMonomerMap(seqCol: DG.Column<string>, tableRowIdx: number): MonomerMap | null {
+    const seq = seqCol.get(tableRowIdx);
+    if (seq == null) return null;
+
+    let resMonomerMap = monomerMapLruCache.get(seq);
+    if (!resMonomerMap)
+      monomerMapLruCache.set(seq, resMonomerMap = buildMonomerMap(seqCol, tableRowIdx));
+
+    return resMonomerMap;
+  }
+
+  const resLink: MonomerHoverLink = {
+    targetCol: molCol,
+    handler: (seqGridCell: DG.GridCell, cyclizedMonomer: ISeqMonomer | null, targetGridCol: DG.GridColumn): boolean => {
+      const grid = targetGridCol.grid;
+      const tableRowIdx = seqGridCell.tableRowIndex!;
+      const gridRowIdx = seqGridCell.gridRow;
+      const targetGridCell = grid.cell(targetGridCol.name, gridRowIdx);
+
+      const prev = getMonomerHover();
+      if (!prev || (prev && (prev.dataFrameId != seqCol.dataFrame.id || prev.gridRowIdx != gridRowIdx ||
+        prev.seqColName != seqCol.name || prev.seqPosition != cyclizedMonomer?.position))
+      ) {
+        if (prev) {
+          setMonomerHover(null);
+          prev.gridCell.grid?.invalidate();
+          // prev.gridCell.render();
+        }
+        if (!cyclizedMonomer) {
+          setMonomerHover(null);
+          return true;
+        }
+
+        setMonomerHover({
+          gridCell: targetGridCell,
+          dataFrameId: seqCol.dataFrame.id,
+          gridRowIdx: gridRowIdx,
+          seqColName: seqCol.name,
+          seqPosition: cyclizedMonomer ? cyclizedMonomer.position : -1,
+          getSubstruct: (): ISubstruct | undefined => { // Gets monomer highlight
+            if (!cyclizedMonomer || cyclizedMonomer.symbol === '*')
+              return undefined;
+
+            const molMonomerMap = getMonomerMap(seqCol, tableRowIdx);
+            if (!molMonomerMap)
+              return undefined;
+
+            const resSubstructList: ISubstruct[] = [];
+            const seqMonomerList: number[] = [cyclizedMonomer.position]; // TODO: Map position of harmonized sequence
+            for (const seqMonomer of seqMonomerList) {
+              const monomerMap = molMonomerMap.get(cyclizedMonomer!.position); // single monomer
+              if (!monomerMap) return {atoms: [], bonds: [], highlightAtomColors: [], highlightBondColors: []};
+              resSubstructList.push(getMolHighlight([monomerMap], monomerLib));
+            }
+            //TODO: refine merge substract
+            //const res: ISubstruct = mergeSubstructs(resSubstructList);
+            return undefined;
+          }
+        });
+
+        // TODO: Invalidate targetGridCell
+        grid.invalidate();
+        // targetGridCell.render();
+      }
+
+      return true;
+    },
+    /* ISubstructProvider.*/getSubstruct: (tableRowIdx: number | null): ISubstruct | undefined =>{
+      // Gets whole molecule highlight
+      if (molCol.getTag(ChemTags.SEQUENCE_SRC_HL_MONOMERS) != 'true') return undefined;
+      if (tableRowIdx == null) return undefined;
+      const seq = seqCol.get(tableRowIdx);
+      if (!seq) return undefined;
+
+      const molMonomerMap = getMonomerMap(seqCol, tableRowIdx);
+      if (!molMonomerMap) return undefined;
+      const res: ISubstruct = getMolHighlight(molMonomerMap.values(), monomerLib);
+      return res;
+    }
+  };
+
+  addMonomerHoverLink(cyclizedCol.temp, resLink);
+  // addSubstructProvider(molCol.temp, resLink); //
+
+  return resLink;
+}