@datagrok/sequence-translator 1.6.4 → 1.7.0

package/src/polytool/pt-dialog.ts

@@ -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;
@@ -259,16 +262,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 +276,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 +288,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 +316,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);
@@ -399,6 +357,7 @@ function buildCyclizedMonomerHoverLink(
       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 ||
@@ -429,15 +388,16 @@ function buildCyclizedMonomerHoverLink(
               return undefined;
 
             const resSubstructList: ISubstruct[] = [];
-            const seqMonomerList: number[] = [cyclizedMonomer.position]; // TODO: Map position of harmonized sequence
+            const seqMonomerList: number[] = positionMap[cyclizedMonomer.position];
+            console.log(seqMonomerList);
             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;
           }
         });
 
@@ -463,7 +423,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

@@ -656,8 +656,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;

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);