@datagrok/sequence-translator 1.9.10 → 1.9.12

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

@@ -1,12 +1,19 @@
+/* eslint-disable max-len */
 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 {getMonomerPairs, getRules, LinkRuleRowArgs, Rules} from './pt-rules';
 import {_package, PackageFunctions} 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';
+import {getOverriddenLibrary} from './pt-synthetic';
+import {MmcrTemps} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
+import {helmToMol} from './pt-atomic';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {getReactionEditor, ReactionEditorProps} from './rule-reaction-editor';
 
 
 const TAB_LINKS = 'Links';
@@ -24,15 +31,27 @@ export class RulesManager {
   heteroDimerInput: DG.InputBase;
 
   linkCards: RuleCards[];
+  addLinkRulesFunc: (rowObj: LinkRuleRowArgs) => void;
+  addSynthRulesFunc: (rowObj: ReactionEditorProps) => void;
 
   // every rule set will have its editor instance
   private static instances: Record<string, RulesManager> = {};
 
   protected constructor(rules: Rules, fileName: string) {
     this.rules = rules;
-    this.linkRuleDataFrame = this.rules.getLinkRulesDf();
-
-    this.synthRuleDataFrame = this.rules.getSynthesisRulesDf();
+    const linksRes = this.rules.getLinkRulesDf();
+    this.linkRuleDataFrame = linksRes.res;
+    this.addLinkRulesFunc = linksRes.addNewRow;
+
+    const synthRes = this.rules.getSynthesisRulesDf();
+    this.addSynthRulesFunc = (r) => {
+      synthRes.addNewRow(r);
+      this.rules.setSynthesisRules(synthRes.df);
+      this.synthRuleDataFrame = synthRes.df;
+      this.substituteReactionGridDataFrame?.();
+      this.save();
+    };
+    this.synthRuleDataFrame = synthRes.df;
     this.fileName = fileName;
 
     const homoValue = this.rules.homodimerCode ? this.rules.homodimerCode : '';
@@ -166,23 +185,57 @@ export class RulesManager {
 
     const initCol = DG.Column.fromStrings('Monomers', seqs);
     const helmCol = DG.Column.fromStrings('Helm', helms);
-
+    const df = DG.DataFrame.fromColumns([
+      initCol, helmCol
+    ]);
     initCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    const rdKitModule = await getRdKitModule();
+    const seqHelper = await getSeqHelper();
+    // initialize seqHandler for this column
     PackageFunctions.applyNotationProviderForCyclized(initCol, '-');
+    initCol.tags[DG.TAGS.CELL_RENDERER] = 'Sequence';
 
     helmCol.semType = DG.SEMTYPE.MACROMOLECULE;
     helmCol.meta.units = NOTATION.HELM;
     helmCol.setTag(DG.TAGS.CELL_RENDERER, 'helm');
-    return DG.DataFrame.fromColumns([
-      initCol, helmCol
-    ]).plot.grid();
+
+    const lib = await getOverriddenLibrary(this.rules);
+    const resHelmColTemp = helmCol.temp;
+    resHelmColTemp[MmcrTemps.overriddenLibrary] = lib;
+    helmCol.temp = resHelmColTemp;
+
+    const resMolCol = await helmToMol(helmCol, seqs,
+      isLinear, true, false, false, lib, rdKitModule, seqHelper);
+    resMolCol.name = `molfile(sequence)`;
+    resMolCol.semType = DG.SEMTYPE.MOLECULE;
+    df.columns.add(resMolCol);
+
+    return df.plot.grid();
   }
 
+  private substituteReactionGridDataFrame: (() => void) | null = null;
+
   async getForm() {
-    inputsTabControl: DG.TabControl;
+    const gridOptions: Partial<DG.IGridSettings> = {showAddNewRowIcon: false, allowEdit: false, rowHeight: 60};
+
+    const linksGrid = this.linkRuleDataFrame.plot.grid(gridOptions);
+    linksGrid.onCellDoubleClick.subscribe(() => {
+      if (!linksGrid.dataFrame || linksGrid.dataFrame.currentRowIdx == -1 || linksGrid.dataFrame.currentRowIdx == undefined)
+        return;
+      const idx = linksGrid.dataFrame.currentRowIdx;
+      const editArgs: LinkRuleRowArgs = {
+        row: idx,
+        code: this.linkRuleDataFrame.get('code', idx),
+        firstMonomers: this.linkRuleDataFrame.get('firstMonomers', idx),
+        secondMonomers: this.linkRuleDataFrame.get('secondMonomers', idx),
+        firstLinkingGroup: this.linkRuleDataFrame.get('firstLinkingGroup', idx),
+        secondLinkingGroup: this.linkRuleDataFrame.get('secondLinkingGroup', idx),
+      };
+      this.getAddNewLinkRuleDialog(editArgs);
+    });
 
     const linksGridDiv = this.createGridDiv('Rules',
-      this.linkRuleDataFrame.plot.grid({showAddNewRowIcon: true}),
+      linksGrid,
       'specification for monomers to link and linking positions');
     const linkExamples = this.createGridDiv('Examples', await this.getLinkExamplesGrid(),
       'specification for monomers to link and linking positions');
@@ -205,7 +258,7 @@ export class RulesManager {
     this.linkRuleDataFrame.currentRowIdx = 0;
     this.linkRuleDataFrame.onCurrentRowChanged.subscribe(async () => {
       const idx = this.linkRuleDataFrame.currentRowIdx;
-      if (idx !== -1) {
+      if (idx !== -1 && idx != undefined) {
         ui.empty(gridDiv);
         gridDiv.append(ui.splitV([
           ui.box(
@@ -214,17 +267,37 @@ export class RulesManager {
           ),
           this.linkCards[idx].root,
         ]));
+        this.linkCards[idx].render();
+        await this.linkCards[idx].reset();
       }
-
-      this.linkCards[idx].render();
-      await this.linkCards[idx].reset();
     });
 
     const links = ui.splitH([linksGridDiv, gridDiv], null, true);
+    const synthesisGrid = this.synthRuleDataFrame.plot.grid({showAddNewRowIcon: false, allowEdit: false, rowHeight: 130});
+    synthesisGrid.onCellDoubleClick.subscribe(() => {
+      if (!synthesisGrid.dataFrame || synthesisGrid.dataFrame.currentRowIdx == -1 || synthesisGrid.dataFrame.currentRowIdx == undefined)
+        return;
+      const idx = synthesisGrid.dataFrame.currentRowIdx;
+      const editArgs: ReactionEditorProps = {
+        rowIndex: idx,
+        code: this.synthRuleDataFrame.get('code', idx),
+        firstMonomers: this.synthRuleDataFrame.get('firstMonomers', idx).split(',').map((s: string) => s.trim()).filter((s: string) => s),
+        secondMonomers: this.synthRuleDataFrame.get('secondMonomers', idx).split(',').map((s: string) => s.trim()).filter((s: string) => s),
+        resultMonomerName: this.synthRuleDataFrame.get('name', idx),
+        firstReactantSmiles: this.synthRuleDataFrame.get('firstReactant', idx),
+        secondReactantSmiles: this.synthRuleDataFrame.get('secondReactant', idx),
+        productSmiles: this.synthRuleDataFrame.get('product', idx),
+      };
+      getReactionEditor((props: ReactionEditorProps) => this.addSynthRulesFunc(props), editArgs);
+    });
+    const reactionsGridDiv = this.createGridDiv('Rules', synthesisGrid);
 
-    const reactionsGridDiv = this.createGridDiv('Rules',
-      this.synthRuleDataFrame.plot.grid({showAddNewRowIcon: true}));
-    const reactionExamples = this.createGridDiv('Examples', await this.getReactionExamplesGrid());
+    const reactionExamplesGrid = await this.getReactionExamplesGrid();
+    const reactionExamples = this.createGridDiv('Examples', reactionExamplesGrid);
+    this.substituteReactionGridDataFrame = async () => {
+      const newGrid = await this.getReactionExamplesGrid();
+      reactionExamplesGrid.dataFrame = newGrid.dataFrame;
+    };
     reactionsGridDiv.style.width = '50%';
     reactionExamples.style.width = '50%';
     const reactions = ui.divH([reactionsGridDiv, reactionExamples]);
@@ -260,11 +333,39 @@ export class RulesManager {
     const addButton = ui.button('Add rule', () => {
       const currentTab = inputsTabControl.currentPane.name;
       if (currentTab == TAB_LINKS)
-        this.linkRuleDataFrame.rows.addNew();
+        this.getAddNewLinkRuleDialog();
       else if (currentTab == TAB_REACTIONS)
-        this.synthRuleDataFrame.rows.addNew();
+        getReactionEditor((props: ReactionEditorProps) => this.addSynthRulesFunc(props));
     });
-    const topPanel = [saveButton, addButton];
+    const removeButton = ui.button('Remove rule', () => {
+      const currentTab = inputsTabControl.currentPane.name;
+      if (currentTab == TAB_LINKS) {
+        if (this.linkRuleDataFrame == null || this.linkRuleDataFrame.currentRowIdx == -1 || this.linkRuleDataFrame.currentRowIdx == undefined)
+          return;
+        const idx = linksGrid.dataFrame.currentRowIdx;
+        ui.dialog('Are you sure you want to remove the rule?')
+          .add(ui.divText('This action is irreversible!'))
+          .onOK(() => {
+            this.linkRuleDataFrame.rows.removeAt(idx);
+            this.rules.setLinkRules(this.linkRuleDataFrame);
+            this.save();
+          }).show();
+      } else if (currentTab == TAB_REACTIONS) {
+        if (this.synthRuleDataFrame == null || this.synthRuleDataFrame.currentRowIdx == -1 || this.synthRuleDataFrame.currentRowIdx == undefined)
+          return;
+        const idx = synthesisGrid.dataFrame.currentRowIdx;
+        ui.dialog('Are you sure you want to remove the rule?')
+          .add(ui.divText('This action is irreversible!'))
+          .onOK(() => {
+            this.synthRuleDataFrame.rows.removeAt(idx);
+            this.rules.setSynthesisRules(this.synthRuleDataFrame);
+            this.substituteReactionGridDataFrame?.();
+            this.save();
+          }).show();
+      }
+    });
+
+    const topPanel = [saveButton, addButton, removeButton];
     this.v!.setRibbonPanels([topPanel]);
 
     panel.style.height = '100%';
@@ -272,5 +373,39 @@ export class RulesManager {
 
     return inputsTabControl.root;
   }
+
+  getAddNewLinkRuleDialog(preset?: Partial<LinkRuleRowArgs>): void {
+    const codeInput = ui.input.int('Code', {nullable: false, value: preset?.code});
+    const firstMonomersInput = ui.input.string('First monomers', {placeholder: 'E.g. C,D,E', value: preset?.firstMonomers,
+      tooltipText: 'Comma separated list of first monomers applicable for the rule. If left empty, all monomers will be considered', nullable: true});
+    const secondMonomersInput = ui.input.string('Second monomers', {placeholder: 'E.g. C,D,E', value: preset?.secondMonomers,
+      tooltipText: 'Comma separated list of second monomers applicable for the rule. If left empty, all monomers will be considered', nullable: true});
+    const firstLinkingGroup = preset?.firstLinkingGroup ? `R${preset.firstLinkingGroup}` : 'R3';
+    const secondLinkingGroup = preset?.secondLinkingGroup ? `R${preset.secondLinkingGroup}` : 'R3';
+    const firstLinkingGroupInput = ui.input.choice('First linking group', {value: firstLinkingGroup, items: ['R1', 'R2', 'R3', 'R4'],
+      tooltipText: 'Specifies which R-group of the first monomer will be used for linking', nullable: false});
+    const secondLinkingGroupInput = ui.input.choice('Second linking group', {value: secondLinkingGroup, items: ['R1', 'R2', 'R3', 'R4'],
+      tooltipText: 'Specifies which R-group of the second monomer will be used for linking', nullable: false});
+    ui.dialog('Add new link rule')
+      .add(codeInput)
+      .add(firstMonomersInput)
+      .add(secondMonomersInput)
+      .add(firstLinkingGroupInput)
+      .add(secondLinkingGroupInput)
+      .onOK(async () => {
+        // we rely on validation of inputs by DG inputs
+        const code = codeInput.value!;
+        const firstMonomers = (firstMonomersInput.value ?? '').split(',').map((s) => s.trim()).filter((s) => s).join(',');
+        const secondMonomers = (secondMonomersInput.value ?? '').split(',').map((s) => s.trim()).filter((s) => s).join(',');
+        const firstLinkingGroup = parseInt(firstLinkingGroupInput.value!.substring(1));
+        const secondLinkingGroup = parseInt(secondLinkingGroupInput.value!.substring(1));
+        this.addLinkRulesFunc({code, firstMonomers: firstMonomers ?? '', secondMonomers: secondMonomers ?? '',
+          firstLinkingGroup, secondLinkingGroup, row: preset?.row});
+
+        this.rules.setLinkRules(this.linkRuleDataFrame);
+        this.linkCards = await this.rules.getLinkCards();
+        this.save();
+      }).show();
+  }
 }
 

package/src/polytool/conversion/rule-reaction-editor.ts

@@ -0,0 +1,125 @@
+/* eslint-disable max-len */
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+
+function correctRGroups(smiles: string): string {
+  const elementRGroupRegex = /\[R[1-9]\]/g;
+  // replace all [R1] with [*:1]
+  let correctedSmiles = smiles.replaceAll(elementRGroupRegex, (match) => {
+    const rGroupNum = match[2];
+    return `[*:${rGroupNum}]`;
+  });
+
+  // in some scenarios, rgroups can be written as [2*]
+  const elementRGroupRegex2 = /\[\d\*\]/g;
+  correctedSmiles = correctedSmiles.replaceAll(elementRGroupRegex2, (match) => {
+    const rGroupNum = match[1];
+    return `[*:${rGroupNum}]`;
+  });
+
+  // in some other scenarios, rgroups can be written as [1*:1] or [1*:0]
+  const elementRGroupRegex3 = /\[\d\*\:\d\]/g;
+  return correctedSmiles.replaceAll(elementRGroupRegex3, (match) => {
+    const rGroupNum = match[1];
+    return `[*:${rGroupNum}]`;
+  });
+}
+
+function rgroupToRadicalForm(smiles: string): string {
+  // here we are sure that all rgroups are in the form [*:1], [*:2], ..., [*:9]
+  // replace all [*:1] with [C:1] to mark carbons
+  return smiles.replaceAll(/\[\*\:\d\]/g, (match) => {
+    const rGroupNum = match[3];
+    return `[C:${rGroupNum}]`;
+  });
+}
+
+function radicalToRgroupForm(smiles: string): string {
+  // here we are sure that all marked carbons are in the form [C:1], [C:2], ..., [C:9]
+  // replace all [C:1] with [*:1]
+  return smiles.replaceAll(/\[C\:\d\]/g, (match) => {
+    const rGroupNum = match[3];
+    return `[*:${rGroupNum}]`;
+  });
+}
+
+export type ReactionEditorProps = {
+    resultMonomerName: string,
+    firstReactantSmiles: string,
+    secondReactantSmiles: string,
+    productSmiles: string,
+    firstMonomers: string[],
+    secondMonomers: string[],
+    code: number,
+    rowIndex?: number,
+}
+
+export function getReactionEditor(onOk: (props: ReactionEditorProps) => void, preset?: ReactionEditorProps) {
+  // preset smiles are in radical form, need to convert to rgroup form
+  const firstReactant = preset?.firstReactantSmiles ? radicalToRgroupForm(preset.firstReactantSmiles) : '[*:1]C';
+  const secondReactant = preset?.secondReactantSmiles ? radicalToRgroupForm(preset.secondReactantSmiles) : '[*:2]C';
+  const product = preset?.productSmiles ? radicalToRgroupForm(preset.productSmiles) : '[*:1]CC[*:2]';
+  const code = preset?.code;
+  const firstMonomers = preset?.firstMonomers ?? [];
+  const secondMonomers = preset?.secondMonomers ?? [];
+  const resultMonomerName = preset?.resultMonomerName ?? '';
+
+  const codeInput = ui.input.int('Code', {value: code, nullable: false, showPlusMinus: false, showSlider: false, tooltipText: 'Reaction code'});
+  const firstMonomersInput = ui.input.string('First monomers', {value: firstMonomers.join(','), nullable: false, tooltipText: 'Comma-separated list of monomers for the first reactant'});
+  const secondMonomersInput = ui.input.string('Second monomers', {value: secondMonomers.join(','), nullable: false, tooltipText: 'Comma-separated list of monomers for the second reactant'});
+  const resultMonomerNameInput = ui.input.string('Result monomer name', {value: resultMonomerName, nullable: false, tooltipText: 'Name of the resulting pseudo-monomer generated by the reaction of the two reactants'});
+
+  const firstReactantInput = ui.input.molecule('First reactant', {value: firstReactant, nullable: false, tooltipText: 'Reactant fragment of first monomer(s). Use numbered R groups in correspondence with the rest of the molecule.'});
+  const secondReactantInput = ui.input.molecule('Second reactant', {value: secondReactant, nullable: false, tooltipText: 'Reactant fragment of second monomer(s). Use numbered R groups in correspondence with the rest of the molecule.'});
+  const productInput = ui.input.molecule('Product', {value: product, nullable: false, tooltipText: 'Product fragment of the resulting monomer from the reaction of the two reactants. Use numbered R groups in correspondence with the reactants.'});
+
+  const validate = () => {
+    if (!firstReactantInput || !secondReactantInput || !productInput)
+      return 'Inputs not initialized yet';
+    const firstSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(firstReactantInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    const secondSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(secondReactantInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    const productSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(productInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    if (!firstSmiles || !secondSmiles || !productSmiles)
+      return 'First/Second Reactants and Product must all be set';
+    if (firstSmiles.indexOf('[C:1]') == -1)
+      return 'First Reactant must contain R1-group';
+    if (secondSmiles.indexOf('[C:2]') == -1)
+      return 'Second Reactant must contain R2-group';
+    if (productSmiles.indexOf('[C:1]') == -1 || productSmiles.indexOf('[C:2]') == -1)
+      return 'Product must contain R1- and R2-groups';
+    return null;
+  };
+  firstReactantInput.addValidator(validate);
+  secondReactantInput.addValidator(validate);
+  productInput.addValidator(validate);
+  const dialog = ui.dialog(preset ? 'Edit Reaction Rule' : 'Add Reaction Rule')
+    .add(codeInput)
+    .add(resultMonomerNameInput)
+    .add(firstMonomersInput)
+    .add(secondMonomersInput)
+    .add(firstReactantInput)
+    .add(secondReactantInput)
+    .add(productInput);
+  dialog.addButton('Save', () => {
+    const validationError = validate();
+    if (validationError != null) {
+      grok.shell.warning(validationError);
+      return;
+    }
+    const firstSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(firstReactantInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    const secondSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(secondReactantInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    const productSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(productInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    onOk({
+      code: codeInput.value!,
+      resultMonomerName: resultMonomerNameInput.value,
+      firstMonomers: firstMonomersInput.value.split(',').map((s) => s.trim()).filter((s) => s.length > 0),
+      secondMonomers: secondMonomersInput.value.split(',').map((s) => s.trim()).filter((s) => s.length > 0),
+      firstReactantSmiles: firstSmiles,
+      secondReactantSmiles: secondSmiles,
+      productSmiles: productSmiles,
+      rowIndex: preset?.rowIndex});
+    dialog.close();
+  });
+  dialog.show();
+}

package/src/polytool/conversion/style.css

@@ -7,9 +7,9 @@
     align-items: center;
     cursor: pointer;
     width: 200px;
-    height: 210px;
+    height: 240px;
     min-width: 200px;
-    min-height: 210px;
+    min-height: 240px;
 }
 
 .monomer-card-info-rules {

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

@@ -76,14 +76,14 @@ category('PolyTool: Convert', () => {
     'cyclized-D(2)-NH2(2)-3-0': {
       src: {seq: 'R-F-D(2)-T-G-H-F-Y-P-NH2(2)'},
       tgt: {
-        helm: 'PEPTIDE1{R.F.D.T.G.H.F.Y.P.[NH2]}$PEPTIDE1,PEPTIDE1,10:R2-3:R3$$$V2.0',
+        helm: 'PEPTIDE1{R.F.D.T.G.H.F.Y.P.[NH2]}$PEPTIDE1,PEPTIDE1,3:R3-10:R2$$$V2.0',
         mol: {atomCount: 81, bondCount: 86, inchiKey: 'CBMGNYKOZWNVNK-AHGCAHLCSA-N'},
       }
     },
     'cyclized-D(2)-NH2(2)-0-0': {
       src: {seq: 'D(2)-T-G-H-F-Y-P-NH2(2)'},
       tgt: {
-        helm: 'PEPTIDE1{D.T.G.H.F.Y.P.[NH2]}$PEPTIDE1,PEPTIDE1,8:R2-1:R3$$$V2.0',
+        helm: 'PEPTIDE1{D.T.G.H.F.Y.P.[NH2]}$PEPTIDE1,PEPTIDE1,1:R3-8:R2$$$V2.0',
         mol: {atomCount: 59, bondCount: 63, inchiKey: 'HGRHAUQBJXFERJ-MUFWPYSASA-N'},
       }
     },