@datagrok/sequence-translator 1.6.4 → 1.8.0

package/src/polytool/pt-dialog.ts

@@ -10,7 +10,7 @@ import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getSeqHelper, ISeqHelper, ToAtomicLevelRes} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {MmcrTemps} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
-import {addMonomerHoverLink, buildMonomerHoverLink} from '@datagrok-libraries/bio/src/monomer-works/monomer-hover';
+import {addMonomerHoverLink} 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';
 
@@ -37,10 +37,13 @@ import {PolymerTypes} from '@datagrok-libraries/js-draw-lite/src/types/org';
 import {_toAtomicLevel, 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 {addSubstructProvider, 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';
+import {mergeSubstructs} from '@datagrok-libraries/chem-meta/src/types';
 import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {dealGroups, helmToMol} from './conversion/pt-atomic';
 
 type PolyToolConvertSerialized = {
   generateHelm: boolean;
@@ -65,10 +68,10 @@ export async function polyToolEnumerateChemUI(cell?: DG.Cell): Promise<void> {
 
 export async function polyToolConvertUI(): Promise<void> {
   await _package.initPromise;
-  let dialog: DG.Dialog;
+  let dialog: DG.Dialog | null = null;
   try {
     dialog = await getPolyToolConvertDialog();
-    dialog.show();
+    dialog?.show();
   } catch (err: any) {
     const [errMsg, errStack] = errInfo(err);
     grok.shell.warning('To run PolyTool Conversion, open a dataframe with macromolecules');
@@ -76,25 +79,38 @@ export async function polyToolConvertUI(): Promise<void> {
   }
 }
 
-export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.Dialog> {
+export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.Dialog | null> {
   const subs: Unsubscribable[] = [];
   const destroy = () => {
     for (const sub of subs) sub.unsubscribe();
   };
   try {
     let srcColVal: DG.Column<string> | undefined = srcCol;
+    const srcColList = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
+    const customSrcCols = srcColList.filter((col) => {
+      const sh = _package.seqHelper.getSeqHandler(col);
+      return sh.notation === NOTATION.CUSTOM;
+    });
     if (!srcColVal) {
-      const srcColList = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
       if (srcColList.length < 1)
         throw new Error(PT_ERROR_DATAFRAME);
+      
+      if (customSrcCols.length < 1) {
+        const toAtomicLevelFunc = DG.Func.find({package: 'Bio', name: 'toAtomicLevel'})[0];
+        if (toAtomicLevelFunc) {
+          toAtomicLevelFunc.prepare().edit();
+          return null;
+        }
+        grok.shell.warning('Polytool requires a macromolecule column with custom notation. \n\nUse Top menu | Bio | Transform | To Atomic Level.');
+        return null;
+      }
+
       srcColVal = srcColList[0];
     }
     const srcColInput = ui.input.column('Column', {
       table: srcColVal.dataFrame, value: srcColVal,
       filter: (col: DG.Column) => {
-        if (col.semType !== DG.SEMTYPE.MACROMOLECULE) return false;
-        const sh = _package.seqHelper.getSeqHandler(col);
-        return sh.notation === NOTATION.CUSTOM;
+        return customSrcCols.includes(col);
       }
     });
 
@@ -259,16 +275,6 @@ async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dial
   }
 }
 
-function dealGroups(col: DG.Column<string>): void {
-  for (let i = 0; i < col.length; i++) {
-    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'));
-  }
-}
-
 /** Returns Helm and molfile columns.  */
 export async function polyToolConvert(seqCol: DG.Column<string>,
   generateHelm: boolean, linearize: boolean, chiralityEngine: boolean, highlight: boolean, ruleFiles: string[]
@@ -283,7 +289,7 @@ export async function polyToolConvert(seqCol: DG.Column<string>,
 
     const table = seqCol.dataFrame;
     const rules = await getRules(ruleFiles);
-    const [resList, isLinear] = doPolyToolConvert(seqCol.toList(), rules, helmHelper);
+    const [resList, isLinear, positionMaps] = doPolyToolConvert(seqCol.toList(), rules, helmHelper);
 
     const resHelmColName = getUnusedName(table, `transformed(${seqCol.name})`);
     const resHelmCol = DG.Column.fromType(DG.COLUMN_TYPE.STRING, resHelmColName, resList.length)
@@ -295,61 +301,25 @@ export async function polyToolConvert(seqCol: DG.Column<string>,
 
 
     const rdKitModule: RDModule = await getRdKitModule();
+    const seqHelper: ISeqHelper = await getSeqHelper();
+
     const lib = await getOverriddenLibrary(rules);
     const resHelmColTemp = resHelmCol.temp;
     resHelmColTemp[MmcrTemps.overriddenLibrary] = lib;
     resHelmCol.temp = resHelmColTemp;
 
-    const seqHelper: ISeqHelper = await getSeqHelper();
-    const toAtomicLevelRes =
-      await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, highlight, lib);
-
-    const resMolCol = toAtomicLevelRes.molCol!;
-
-
-    const allLinear = isLinear.filter((l) => l).length;
-    if (linearize && allLinear > 0) {
-      const lin = new Array<string>(allLinear);
-      let counter = 0;
-      for (let i = 0; i < isLinear.length; i++) {
-        if (isLinear[i]) {
-          lin[counter] = resList[i];
-          counter++;
-        }
-      }
-
-      const linCol = DG.Column.fromStrings('helm', lin);
-      linCol.semType = DG.SEMTYPE.MACROMOLECULE;
-      linCol.meta.units = NOTATION.HELM;
-      linCol.setTag(DG.TAGS.CELL_RENDERER, 'helm');
-
-      const monomerLibHelper = await getMonomerLibHelper();
-      const systemMonomerLib = monomerLibHelper.getMonomerLib();
-      let linear: ToAtomicLevelRes | null = null;
-      try {
-        linear = await _toAtomicLevel(DG.DataFrame.create(0), linCol, systemMonomerLib, seqHelper, rdKitModule);
-        counter = 0;
-        for (let i = 0; i < isLinear.length; i++) {
-          if (isLinear[i]) {
-            resMolCol.set(i, linear!.molCol!.get(counter));
-            counter++;
-          }
-        }
-      } catch (e: any) {
-        grok.shell.warning('PolyTool was not able to linearize sequences');
-      }
-    }
-
-    dealGroups(resMolCol);
+    const resMolCol = await helmToMol(resHelmCol, resList,
+      isLinear, chiralityEngine, highlight, linearize, lib, rdKitModule, seqHelper);
     resMolCol.name = getUnusedName(table, `molfile(${seqCol.name})`);
     resMolCol.semType = DG.SEMTYPE.MOLECULE;
+
     if (table) {
       table.columns.add(resMolCol, true);
       await grok.data.detectSemanticTypes(table);
     }
 
-    buildMonomerHoverLink(resHelmCol, resMolCol, lib, seqHelper, rdKitModule);
-    buildCyclizedMonomerHoverLink(seqCol, resHelmCol, resMolCol, lib, seqHelper, rdKitModule);
+    //buildMonomerHoverLink(resHelmCol, resMolCol, lib, seqHelper, rdKitModule);
+    buildCyclizedMonomerHoverLink(seqCol, resHelmCol, resMolCol, lib, seqHelper, rdKitModule, positionMaps);
 
     return [resHelmCol, resMolCol];
   } finally {
@@ -359,7 +329,8 @@ export async function polyToolConvert(seqCol: DG.Column<string>,
 
 function buildCyclizedMonomerHoverLink(
   cyclizedCol: DG.Column<string>, seqCol: DG.Column<string>, molCol: DG.Column<string>,
-  monomerLib: IMonomerLibBase, seqHelper: ISeqHelper, rdKitModule: RDModule
+  monomerLib: IMonomerLibBase, seqHelper: ISeqHelper, rdKitModule: RDModule,
+  positionMaps: number[][][]
 ): MonomerHoverLink {
   function buildMonomerMap(seqCol: DG.Column<string>, tableRowIdx: number): MonomerMap {
     const seqSH = seqHelper.getSeqHandler(seqCol);
@@ -395,19 +366,22 @@ function buildCyclizedMonomerHoverLink(
   const resLink: MonomerHoverLink = {
     targetCol: molCol,
     handler: (seqGridCell: DG.GridCell, cyclizedMonomer: ISeqMonomer | null, targetGridCol: DG.GridColumn): boolean => {
+      if (!seqGridCell || !targetGridCol.grid || !seqCol.dataFrame)
+        return true;
       const grid = targetGridCol.grid;
       const tableRowIdx = seqGridCell.tableRowIndex!;
       const gridRowIdx = seqGridCell.gridRow;
       const targetGridCell = grid.cell(targetGridCol.name, gridRowIdx);
+      const positionMap = positionMaps[gridRowIdx];
 
       const prev = getMonomerHover();
-      if (!prev || (prev && (prev.dataFrameId != seqCol.dataFrame.id || prev.gridRowIdx != gridRowIdx ||
+      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();
+          //prev.gridCell.grid?.invalidate();
+          prev.gridCell.render();
         }
         if (!cyclizedMonomer) {
           setMonomerHover(null);
@@ -429,21 +403,21 @@ function buildCyclizedMonomerHoverLink(
               return undefined;
 
             const resSubstructList: ISubstruct[] = [];
-            const seqMonomerList: number[] = [cyclizedMonomer.position]; // TODO: Map position of harmonized sequence
+            const seqMonomerList: number[] = positionMap[cyclizedMonomer.position];
             for (const seqMonomer of seqMonomerList) {
-              const monomerMap = molMonomerMap.get(cyclizedMonomer!.position); // single monomer
+              const monomerMap = molMonomerMap.get(seqMonomer); // 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;
+            const res: ISubstruct = mergeSubstructs(resSubstructList);
+            return res;
           }
         });
 
         // TODO: Invalidate targetGridCell
-        grid.invalidate();
-        // targetGridCell.render();
+        //grid.invalidate();
+        targetGridCell.render();
       }
 
       return true;
@@ -463,7 +437,7 @@ function buildCyclizedMonomerHoverLink(
   };
 
   addMonomerHoverLink(cyclizedCol.temp, resLink);
-  // addSubstructProvider(molCol.temp, resLink); //
+  addSubstructProvider(molCol.temp, resLink);
 
   return resLink;
 }

package/src/polytool/pt-enumerate-seq-dialog.ts

@@ -167,6 +167,9 @@ async function getPolyToolEnumerateDialog(
         resDataRole = (resSeqValue.tags[PolyToolTags.dataRole] as PolyToolDataRole.template) ?? PolyToolDataRole.macromolecule;
       } else {
         const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'seq', [PT_HELM_EXAMPLE]);
+        seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+        const _tempDf = DG.DataFrame.fromColumns([seqCol]);
+        
         seqCol.meta.units = NOTATION.HELM;
         const sh = seqHelper.getSeqHandler(seqCol);
         resSeqValue = sh.getValue(0);
@@ -184,7 +187,7 @@ async function getPolyToolEnumerateDialog(
     const warningsTextDiv = ui.divText('', {style: {color: 'red'}});
     // #### Inputs
     inputs = {
-      macromolecule: helmHelper.createHelmInput(
+      macromolecule: helmHelper.createHelmInput(                                                     
         'Macromolecule', {
           editable: false,
           editorOptions: {
@@ -192,9 +195,20 @@ async function getPolyToolEnumerateDialog(
               monomerNumbering: MonomerNumberingTypes.continuous,
               getMonomer: (a: HelmAtom | HelmType, name?: string): GetMonomerResType => {
                 const aa: HelmAtom = a as HelmAtom;
+
+
                 if (aa.T === 'ATOM') {
-                  const canonicalSymbol = seqValue.getSplitted().getCanonical(aa.bio!.continuousId - 1);
-                  return monomerLibFuncs.getMonomer(aa.bio!.type, canonicalSymbol);
+                  try {
+                    if (!seqValue.isDna() && !seqValue.isRna()) {
+                      const canonicalSymbol = seqValue.getSplitted().getCanonical(aa.bio!.continuousId - 1);
+                      return monomerLibFuncs.getMonomer(aa.bio!.type, canonicalSymbol);
+                    } else {
+                      const canonicalSymbol = seqValue.getSplittedWithSugarsAndPhosphates().getCanonical(aa.bio!.continuousId - 1);
+                      return monomerLibFuncs.getMonomer(aa.bio!.type, canonicalSymbol);
+                    }
+                  } catch (_) {
+                    return monomerLibFuncs.getMonomer(a, name);
+                  }
                 } else { return monomerLibFuncs.getMonomer(a, name); }
               },
             },
@@ -656,8 +670,8 @@ async function getPolyToolEnumerateDialog(
       },
       /* applyInput */ (x: PolyToolEnumerateHelmSerialized): void => {
         //inputs.macromolecule.stringValue = x.macromolecule;
-        inputs.placeholders.stringValue = x.placeholders;
         inputs.enumeratorType.value = x.enumeratorType ?? PolyToolEnumeratorTypes.Single;
+        inputs.placeholders.stringValue = x.placeholders;
         inputs.placeholdersBreadth.stringValue = x.placeholdersBreadth;
         inputs.trivialNameCol.stringValue = x.trivialNameCol;
         inputs.keepOriginal.value = x.keepOriginal ?? false;
@@ -727,7 +741,7 @@ async function polyToolEnumerateSeq(
           toAtomicLevel.chiralityEngine, toAtomicLevel.highlightMonomers);
         enumeratorResDf.columns.add(talRes.molCol!, false);
         const resMolCol = talRes.molCol!;
-        buildMonomerHoverLink(resHelmCol, resMolCol, monomerLib, helmHelper.seqHelper, rdKitModule);
+        await buildMonomerHoverLink(resHelmCol, resMolCol, monomerLib, helmHelper.seqHelper, rdKitModule, true);
       } else if (dataRole === PolyToolDataRole.template) {
         const talRes = await polyToolConvert(enumCol,
           toAtomicLevel.generateHelm, false, toAtomicLevel.chiralityEngine, false, toAtomicLevel.rules);

package/src/tests/polytool-convert-tests.ts

@@ -107,7 +107,7 @@ category('PolyTool: Convert', () => {
   for (const [testName, testData] of Object.entries(tests)) {
     test(`toAtomicLevel-${testName}`, async () => {
       const rules = await getRules(['rules_example.json']);
-      const [helmList, isLinear] = doPolyToolConvert([testData.src.seq], rules, helmHelper);
+      const [helmList, isLinear, positionMaps] = doPolyToolConvert([testData.src.seq], rules, helmHelper);
 
       const lib = await getOverriddenLibrary(rules);