@datagrok/sequence-translator 1.6.3 → 1.7.0

package/src/polytool/conversion/rule-manager.ts

@@ -1,10 +1,17 @@
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
 import {getMonomerPairs, getRules, Rules} from './pt-rules';
 import {_package, applyNotationProviderForCyclized} from '../../package';
 import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {doPolyToolConvert} from './pt-conversion';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {RuleCards} from './pt-rule-cards';
+
+
+const TAB_LINKS = 'Links';
+const TAB_REACTIONS = 'Reactions';
+const TAB_DIMERS = 'Dimers';
 
 export class RulesManager {
   rules: Rules;
@@ -16,7 +23,7 @@ export class RulesManager {
   homoDimerInput: DG.InputBase;
   heteroDimerInput: DG.InputBase;
 
-  currentTab = '';
+  linkCards: RuleCards[];
 
   // every rule set will have its editor instance
   private static instances: Record<string, RulesManager> = {};
@@ -24,6 +31,7 @@ export class RulesManager {
   protected constructor(rules: Rules, fileName: string) {
     this.rules = rules;
     this.linkRuleDataFrame = this.rules.getLinkRulesDf();
+
     this.synthRuleDataFrame = this.rules.getSynthesisRulesDf();
     this.fileName = fileName;
 
@@ -92,20 +100,16 @@ export class RulesManager {
     grok.shell.info(`Polytool rules at ${this.fileName} was updated`);
   }
 
-  private createGridDiv(name: string, grid: DG.Grid, buttons: HTMLButtonElement[] = []) {
+  private createGridDiv(name: string, grid: DG.Grid, tooltipMsg?: string) {
     const header = ui.h1(name, 'polytool-grid-header');
+    ui.tooltip.bind(header, tooltipMsg);
     header.style.marginTop = '10px';
     header.style.marginRight = '10px';
     grid.root.style.height = '100%';
 
-    buttons.forEach((b) => {
-      b.style.marginLeft = '5px';
-      b.style.marginRight = '10px';
-    });
-
     const gridDiv = ui.splitV([
       ui.box(
-        ui.divH([header, ...buttons]),
+        header,
         {style: {maxHeight: '60px'}},
       ),
       grid.root,
@@ -129,10 +133,10 @@ export class RulesManager {
     }
     const helmHelper = await getHelmHelper();
 
-    const helms = doPolyToolConvert(seqs, this.rules, helmHelper);
+    const [helms, isLinear, positionMaps] = doPolyToolConvert(seqs, this.rules, helmHelper);
 
-    const initCol = DG.Column.fromStrings('monomers', seqs);
-    const helmCol = DG.Column.fromStrings('helm', helms);
+    const initCol = DG.Column.fromStrings('Monomers', seqs);
+    const helmCol = DG.Column.fromStrings('Helm', helms);
 
     applyNotationProviderForCyclized(initCol, '-');
     initCol.semType = DG.SEMTYPE.MACROMOLECULE;
@@ -158,10 +162,10 @@ export class RulesManager {
     }
     const helmHelper = await getHelmHelper();
 
-    const helms = doPolyToolConvert(seqs, this.rules, helmHelper);
+    const [helms, isLinear, positionMaps] = doPolyToolConvert(seqs, this.rules, helmHelper);
 
-    const initCol = DG.Column.fromStrings('monomers', seqs);
-    const helmCol = DG.Column.fromStrings('helm', helms);
+    const initCol = DG.Column.fromStrings('Monomers', seqs);
+    const helmCol = DG.Column.fromStrings('Helm', helms);
 
     initCol.semType = DG.SEMTYPE.MACROMOLECULE;
     applyNotationProviderForCyclized(initCol, '-');
@@ -177,19 +181,49 @@ export class RulesManager {
   async getForm() {
     inputsTabControl: DG.TabControl;
 
-    const saveLinksButton = ui.bigButton('Save', () => { this.save(); });
-    const addLinkButton = ui.button('Add rule', () => { this.linkRuleDataFrame.rows.addNew(); });
     const linksGridDiv = this.createGridDiv('Rules',
-      this.linkRuleDataFrame.plot.grid({showAddNewRowIcon: true}), [saveLinksButton, addLinkButton]);
-    const linkExamples = this.createGridDiv('Examples', await this.getLinkExamplesGrid());
+      this.linkRuleDataFrame.plot.grid({showAddNewRowIcon: true}),
+      'specification for monomers to link and linking positions');
+    const linkExamples = this.createGridDiv('Examples', await this.getLinkExamplesGrid(),
+      'specification for monomers to link and linking positions');
     linksGridDiv.style.width = '50%';
     linkExamples.style.width = '50%';
-    const links = ui.divH([linksGridDiv, linkExamples]);
+    const header = ui.h1('Monomers', 'polytool-grid-header');
+    ui.tooltip.bind(header, 'Click different cobination to see how monomers will link');
+    this.linkCards = await this.rules.getLinkCards();
+    const gridDiv: HTMLElement = ui.splitV([
+      ui.box(
+        header,
+        {style: {maxHeight: '30px'}},
+      ),
+      this.linkCards[0].root,
+    ]);
+
+    this.linkCards[0].render();
+    await this.linkCards[0].reset();
+
+    this.linkRuleDataFrame.currentRowIdx = 0;
+    this.linkRuleDataFrame.onCurrentRowChanged.subscribe(async () => {
+      const idx = this.linkRuleDataFrame.currentRowIdx;
+      if (idx !== -1) {
+        ui.empty(gridDiv);
+        gridDiv.append(ui.splitV([
+          ui.box(
+            header,
+            {style: {maxHeight: '30px'}},
+          ),
+          this.linkCards[idx].root,
+        ]));
+      }
+
+      this.linkCards[idx].render();
+      await this.linkCards[idx].reset();
+    });
+
+    const links = ui.splitH([linksGridDiv, gridDiv], null, true);
 
-    const saveReactionsButton = ui.bigButton('Save', () => { this.save(); });
-    const addReactionButton = ui.button('Add rule', () => { this.synthRuleDataFrame.rows.addNew(); });
     const reactionsGridDiv = this.createGridDiv('Rules',
-      this.synthRuleDataFrame.plot.grid({showAddNewRowIcon: true}), [saveReactionsButton, addReactionButton]);
+      this.synthRuleDataFrame.plot.grid({showAddNewRowIcon: true}));
     const reactionExamples = this.createGridDiv('Examples', await this.getReactionExamplesGrid());
     reactionsGridDiv.style.width = '50%';
     reactionExamples.style.width = '50%';
@@ -206,6 +240,13 @@ export class RulesManager {
       'Dimers': dimerInputsDiv,
     }, false);
 
+    ui.tooltip.bind(inputsTabControl.getPane(TAB_LINKS).header,
+      'Specify rules to link monomers based on HELM notation');
+    ui.tooltip.bind(inputsTabControl.getPane(TAB_REACTIONS).header,
+      'Specify rules to perform reactions within monomers');
+    ui.tooltip.bind(inputsTabControl.getPane(TAB_DIMERS).header,
+      'Specify symbols for homodimeric and heterodimeric codes');
+
     inputsTabControl.root.style.height = '100%';
     inputsTabControl.root.style.width = '100%';
     inputsTabControl.root.classList.add('rules-manager-form-tab-control');
@@ -215,6 +256,17 @@ export class RulesManager {
       inputsTabControl.root,
     ]);
 
+    const saveButton = ui.bigButton('Save', () => { this.save(); });
+    const addButton = ui.button('Add rule', () => {
+      const currentTab = inputsTabControl.currentPane.name;
+      if (currentTab == TAB_LINKS)
+        this.linkRuleDataFrame.rows.addNew();
+      else if (currentTab == TAB_REACTIONS)
+        this.synthRuleDataFrame.rows.addNew();
+    });
+    const topPanel = [saveButton, addButton];
+    this.v!.setRibbonPanels([topPanel]);
+
     panel.style.height = '100%';
     panel.style.alignItems = 'center';
 

package/src/polytool/conversion/style.css

@@ -0,0 +1,32 @@
+.monomer-card-rule-root {
+    border: 2px solid var(--grey-2);
+    border-radius: 5px;
+    padding: 5px;
+    margin: 5px;
+    overflow: hidden;
+    align-items: center;
+    cursor: pointer;
+    width: 200px;
+    height: 210px;
+    min-width: 200px;
+    min-height: 210px;
+}
+
+.monomer-card-info-rules {
+    width: 100%;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    margin-bottom: 10px;
+}
+
+.monomer-card-info-rules > div:nth-child(2) {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.monomer-card-info-rules > div:nth-child(1) {
+    font-weight: bold;
+    margin-right: 5px;
+    text-wrap: nowrap;
+}

package/src/polytool/pt-dialog.ts

@@ -8,7 +8,7 @@ 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 {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+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 {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
@@ -23,7 +23,8 @@ 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_HIGHLIGHT_MONOMERS, PT_UI_RULES_USED, PT_UI_USE_CHIRALITY
+  PT_UI_GET_HELM, PT_UI_LINEARIZE, PT_UI_LINEARIZE_TT,
+  PT_UI_HIGHLIGHT_MONOMERS, PT_UI_RULES_USED, PT_UI_USE_CHIRALITY
 } from './const';
 
 import {_package} from '../package';
@@ -33,12 +34,16 @@ 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 {_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;
@@ -99,6 +104,9 @@ export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.D
     const generateHelmInput = ui.input.bool(PT_UI_GET_HELM, {value: true});
     ui.tooltip.bind(generateHelmInput.root, PT_UI_ADD_HELM);
 
+    const linearizeInput = ui.input.bool(PT_UI_LINEARIZE, {value: true});
+    ui.tooltip.bind(linearizeInput.root, PT_UI_LINEARIZE_TT);
+
     const chiralityEngineInput = ui.input.bool(PT_UI_USE_CHIRALITY, {value: true});
     const highlightMonomersInput = ui.input.bool(PT_UI_HIGHLIGHT_MONOMERS, {value: true});
     let ruleFileList: string[];
@@ -112,6 +120,7 @@ export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.D
     const div = ui.divV([
       srcColInput,
       generateHelmInput,
+      linearizeInput,
       chiralityEngineInput,
       highlightMonomersInput,
       rulesHeader,
@@ -121,7 +130,10 @@ export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.D
     const exec = async (): Promise<void> => {
       try {
         const ruleFileList = await ruleInputs.getActive();
-        await polyToolConvert(srcColInput.value!, generateHelmInput.value!, chiralityEngineInput.value!, ruleFileList);
+        await polyToolConvert(
+          srcColInput.value!, generateHelmInput.value!, linearizeInput.value!,
+          chiralityEngineInput.value!, highlightMonomersInput.value!, ruleFileList
+        );
       } catch (err: any) {
         defaultErrorHandler(err);
       }
@@ -250,19 +262,9 @@ 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, chiralityEngine: boolean, ruleFiles: string[]
+export async function polyToolConvert(seqCol: DG.Column<string>,
+  generateHelm: boolean, linearize: boolean, chiralityEngine: boolean, highlight: boolean, ruleFiles: string[]
 ): Promise<[DG.Column, DG.Column]> {
   const pi = DG.TaskBarProgressIndicator.create('PolyTool converting...');
   try {
@@ -274,7 +276,7 @@ export async function polyToolConvert(
 
     const table = seqCol.dataFrame;
     const rules = await getRules(ruleFiles);
-    const resList = 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)
@@ -284,25 +286,27 @@ export async function polyToolConvert(
     resHelmCol.setTag(DG.TAGS.CELL_RENDERER, 'helm');
     if (generateHelm && table) table.columns.add(resHelmCol, true);
 
-    const seqHelper: ISeqHelper = await getSeqHelper();
+
     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 toAtomicLevelRes =
-      await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, /* highlight */ generateHelm, lib);
-    const resMolCol = toAtomicLevelRes.molCol!;
-    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 {
@@ -312,7 +316,8 @@ export async function polyToolConvert(
 
 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);
@@ -352,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 ||
@@ -382,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;
           }
         });
 
@@ -416,7 +423,7 @@ function buildCyclizedMonomerHoverLink(
   };
 
   addMonomerHoverLink(cyclizedCol.temp, resLink);
-  // addSubstructProvider(molCol.temp, resLink); //
+  addSubstructProvider(molCol.temp, resLink);
 
   return resLink;
 }