@datagrok/sequence-translator 1.4.10 → 1.5.0

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

@@ -0,0 +1,205 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+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';
+
+export class RulesManager {
+  rules: Rules;
+  linkRuleDataFrame: DG.DataFrame;
+  synthRuleDataFrame: DG.DataFrame;
+  fileName: string;
+  v: DG.View | null = null;
+
+  homoDimerInput: DG.InputBase;
+  heteroDimerInput: DG.InputBase;
+
+  currentTab = '';
+
+  private static instance: RulesManager;
+
+  protected constructor(rules: Rules, fileName: string) {
+    this.rules = rules;
+    this.linkRuleDataFrame = this.rules.getLinkRulesDf();
+    this.synthRuleDataFrame = this.rules.getSynthesisRulesDf();
+    this.fileName = fileName;
+
+    const homoValue = this.rules.homodimerCode ? this.rules.homodimerCode : '';
+    const heteroValue = this.rules.heterodimerCode ? this.rules.heterodimerCode : '';
+    this.homoDimerInput = ui.input.string('Homo dimer', {value: homoValue, onValueChanged: () => {}, nullable: false});
+    this.heteroDimerInput = ui.input.string(
+      'Hetero dimer', {value: heteroValue, onValueChanged: () => {}, nullable: false}
+    );
+  }
+
+  async getView(): Promise<DG.ViewBase> {
+    if (!this.v) {
+      this.v = DG.View.create();
+      this.v.append(await this.getForm());
+    }
+
+    return this.v;
+  }
+
+  public static async getInstance(name: string): Promise<RulesManager> {
+    if (!this.instance) {
+      const rules = await getRules([name]);
+      this.instance = new RulesManager(rules, name);
+    }
+    return this.instance;
+  }
+
+  save(): void {
+    this.rules.homodimerCode = this.homoDimerInput.value;
+    this.rules.heterodimerCode = this.heteroDimerInput.value;
+    this.rules.setLinkRules(this.linkRuleDataFrame);
+    this.rules.setSynthesisRules(this.synthRuleDataFrame);
+
+    const saveable = {
+      homodimerCode: this.rules.homodimerCode,
+      heterodimerCode: this.rules.heterodimerCode,
+      linkRules: this.rules.linkRules,
+      reactionRules: this.rules.reactionRules,
+    };
+
+    const rrrr = JSON.stringify(saveable, undefined, 2);
+    _package.files.writeAsText(`polytool-rules/${this.fileName}`, rrrr);
+    grok.shell.info(`Polytool rules at ${this.fileName} was updated`);
+  }
+
+  private createGridDiv(name: string, grid: DG.Grid) {
+    const header = ui.h1(name, 'polytool-grid-header');
+    grid.root.prepend(header);
+    grid.root.style.height = '100%';
+    return grid.root;
+  };
+
+  async getLinkExamplesGrid() {
+    const seqs: string[] = [];
+
+    for (let i = 0; i < this.rules.linkRules.length; i++) {
+      const code = this.rules.linkRules[i].code;
+      const [firstMonomers, secondMonomers] = getMonomerPairs(this.rules.linkRules[i]);
+      for (let j = 0; j < firstMonomers.length; j++) {
+        const seq = `${firstMonomers[j]}(${code})-A-A-A-A-${secondMonomers[j]}(${code})-A`;
+        seqs.push(seq);
+      }
+    }
+    const helmHelper = await getHelmHelper();
+
+    const helms = doPolyToolConvert(seqs, this.rules, helmHelper);
+
+    const initCol = DG.Column.fromStrings('monomers', seqs);
+    const helmCol = DG.Column.fromStrings('helm', helms);
+
+    initCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    applyNotationProviderForCyclized(initCol, '-');
+
+    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();
+  }
+
+  async getReactionExamplesGrid() {
+    const seqs: string[] = [];
+
+    for (let i = 0; i < this.rules.reactionRules.length; i++) {
+      const code = this.rules.reactionRules[i].code;
+      const [firstMonomers, secondMonomers] = getMonomerPairs(this.rules.reactionRules[i]);
+      for (let j = 0; j < firstMonomers.length; j++) {
+        const seq = `${firstMonomers[j]}(${code})-A-A-A-A-${secondMonomers[j]}(${code})-A`;
+        seqs.push(seq);
+      }
+    }
+    const helmHelper = await getHelmHelper();
+
+    const helms = doPolyToolConvert(seqs, this.rules, helmHelper);
+
+    const initCol = DG.Column.fromStrings('monomers', seqs);
+    const helmCol = DG.Column.fromStrings('helm', helms);
+
+    initCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    applyNotationProviderForCyclized(initCol, '-');
+
+    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();
+  }
+
+  async getForm() {
+    inputsTabControl: DG.TabControl;
+
+    const dimerInputsDiv = ui.divV([
+      this.homoDimerInput,
+      this.heteroDimerInput,
+    ]);
+
+    const linkExamples = await this.getLinkExamplesGrid();
+    const reactionExamples = await this.getReactionExamplesGrid();
+
+    const inputsTabControl = ui.tabControl({
+      'Links': linkExamples,
+      'Reactions': reactionExamples,
+      'Dimers': dimerInputsDiv,
+    }, false);
+
+    inputsTabControl.root.style.height = '90%';
+    inputsTabControl.root.style.width = '100%';
+    inputsTabControl.root.classList.add('rules-manager-form-tab-control');
+    inputsTabControl.header.style.marginBottom = '10px';
+
+    const linksGridDiv = this.createGridDiv('Link rules', this.linkRuleDataFrame.plot.grid({showAddNewRowIcon: true}));
+    const reactionsGridDiv =
+      this.createGridDiv('Reaction rules', this.synthRuleDataFrame.plot.grid({showAddNewRowIcon: true}));
+
+    linksGridDiv.style.width = '100%';
+    reactionsGridDiv.style.width = '100%';
+
+    const divs = [linksGridDiv, reactionsGridDiv, ui.div()];
+    divs[0].style.removeProperty('display');
+    divs[1].style.display = 'none';
+    divs[2].style.display = 'none';
+
+    inputsTabControl.onTabChanged.subscribe(() => {
+      this.currentTab = inputsTabControl.currentPane.name;
+
+      const idx = inputsTabControl.panes.findIndex((p) => p.name == this.currentTab);
+
+      for (let i = 0; i < divs.length; i++) {
+        if (i == idx)
+          divs[i].style.removeProperty('display');
+        else
+          divs[i].style.display = 'none';
+      }
+    });
+
+    const saveButton = ui.bigButton('Save changes', () => {
+      this.save();
+    });
+
+
+    const panel = ui.divV([
+      inputsTabControl.root,
+      saveButton
+    ]);
+
+    panel.style.height = '100%';
+    panel.style.alignItems = 'center';
+
+    const form = ui.splitH([
+      panel,
+      ui.divV(divs, {style: {width: '100%'}})
+    ], {style: {width: '100%'}}, true);
+    form.style.height = '100%';
+    return form;
+  }
+}
+

package/src/polytool/pt-convert-editor.ts

@@ -4,7 +4,7 @@ import * as DG from 'datagrok-api/dg';
 import {_package} from '../package';
 import {defaultErrorHandler} from '../utils/err-info';
 import {PT_UI_DIALOG_CONVERSION, PT_UI_RULES_USED} from './const';
-import {RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './conversion/pt-rules';
 
 /** Inputs of polyToolConvert2 package function */
 export enum P {

package/src/polytool/pt-dialog.ts

@@ -14,7 +14,7 @@ import {addMonomerHoverLink, buildMonomerHoverLink} from '@datagrok-libraries/bi
 import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
-import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './conversion/pt-rules';
 import {doPolyToolConvert} from './conversion/pt-conversion';
 import {getOverriddenLibrary} from './conversion/pt-misc';
 import {defaultErrorHandler} from '../utils/err-info';

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

@@ -26,7 +26,7 @@ import {defaultErrorHandler} from '../utils/err-info';
 import {PolyToolPlaceholdersBreadthInput} from './pt-placeholders-breadth-input';
 import {PT_UI_DIALOG_ENUMERATION, PT_UI_GET_HELM, PT_UI_HIGHLIGHT_MONOMERS, PT_UI_RULES_USED, PT_UI_USE_CHIRALITY} from './const';
 import {PolyToolDataRole, PolyToolTags} from '../consts';
-import {RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './conversion/pt-rules';
 import {Chain} from './conversion/pt-chain';
 import {polyToolConvert} from './pt-dialog';
 
@@ -627,9 +627,9 @@ async function polyToolEnumerateSeq(
     }
     const enumeratorResDf = DG.DataFrame.fromColumns([enumCol]);
     await grok.data.detectSemanticTypes(enumeratorResDf);
-    if (dataRole == PolyToolDataRole.template) {
+    if (dataRole == PolyToolDataRole.template)
       applyNotationProviderForCyclized(enumCol, '-');
-    }
+
 
     if (toAtomicLevel) {
       let resHelmCol: DG.Column<string>;

package/src/polytool/pt-unrule-dialog.ts

@@ -10,7 +10,7 @@ import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {defaultErrorHandler} from '../utils/err-info';
 import {doPolyToolUnrule} from './pt-unrule';
-import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './conversion/pt-rules';
 import {PT_ERROR_DATAFRAME, PT_UI_DIALOG_UNRULE, PT_UI_RULES_USED} from './const';
 
 import {_package} from '../package';

package/src/polytool/pt-unrule.ts

@@ -6,7 +6,7 @@ import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 
 import {Chain} from './conversion/pt-chain';
 import {getPolyToolUnruleDialog} from './pt-unrule-dialog';
-import {Rules} from './pt-rules';
+import {Rules} from './conversion/pt-rules';
 
 import {_package} from '../package';
 import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';

package/src/tests/polytool-chain-from-notation-tests.ts

@@ -4,7 +4,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
 import {Chain} from '../polytool/conversion/pt-chain';
-import {getRules} from '../polytool/pt-rules';
+import {getRules} from '../polytool/conversion/pt-rules';
 import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 category('PolyTool: Chain', () => {
@@ -54,15 +54,11 @@ category('PolyTool: Chain', () => {
         templateHelm: 'PEPTIDE1{[(#3)Succ]}' + '|' +
           'PEPTIDE2{[A(CHOL)].F.[C(1)].T.G.H.Y.P.[C(1)].[NH2]}' + '$' +
           'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '$$$' + 'V2.0',
-        mmHelm: 'PEPTIDE1{[Succ].[A(CHOL)].F.C.T.G.H.Y.P.C.[NH2]}' + '|' +
-          'PEPTIDE2{[A(CHOL)].F.C.T.G.H.Y.P.C.[NH2]}' + '$' +
-          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '|' +
-          'PEPTIDE1,PEPTIDE1,4:R3-10:R3' + '|' +
-          'PEPTIDE2,PEPTIDE2,3:R3-9:R3' + '$$$V2.0',
+        mmHelm: 'PEPTIDE1{[(#3)Succ].[{A(CHOL)].F.C.T.G.H.Y.P.C.[NH2}]}$PEPTIDE1,PEPTIDE1,4:R3-10:R3$$$V2.0',
       },
       tgt: {
         templateChain: {monomerCount: [1, 10], linkageCount: 1},
-        mmChain: {monomerCount: [11, 10], linkageCount: 3,}
+        mmChain: {monomerCount: [11], linkageCount: 1}
       }
     },
     'dimerized2': {
@@ -72,15 +68,11 @@ category('PolyTool: Chain', () => {
           'PEPTIDE2{R.F.[C(1)].T.G.H.F.P.[C(1)].[NH2]}' + '|' +
           'PEPTIDE3{[($3)A(CHOL)].F.[C(1)].Y.H.G.D.N.[C(1)].[meI]}' + '$' +
           'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '$$$' + 'V2.0',
-        mmHelm: 'PEPTIDE1{[Succ].R.F.C.T.G.H.F.P.C.[NH2]}' + '|' +
-          'PEPTIDE2{[A(CHOL)].F.C.Y.H.G.D.N.C.[meI]}' + '$' +
-          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '|' +
-          'PEPTIDE1,PEPTIDE1,4:R3-10:R3' + '|' +
-          'PEPTIDE2,PEPTIDE2,3:R3-9:R3' + '$$$V2.0',
+        mmHelm: 'PEPTIDE1{[($3)Succ].[{R].F.C.T.G.H.F.P.C.[NH2}($3){A(CHOL)].F.[C(1)].Y.H.G.D.N.[C(1)].[meI}]}$PEPTIDE1,PEPTIDE1,4:R3-10:R3$$$V2.0',
       },
       tgt: {
-        templateChain: {monomerCount: [1, 10, 10], linkageCount: 1,},
-        mmChain: {monomerCount: [11, 10], linkageCount: 3,}
+        templateChain: {monomerCount: [1, 10, 10], linkageCount: 1},
+        mmChain: {monomerCount: [20], linkageCount: 1}
       }
     }
   };

package/src/tests/polytool-chain-parse-notation-tests.ts

@@ -5,7 +5,7 @@ import * as DG from 'datagrok-api/dg';
 import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
 import {Chain} from '../polytool/conversion/pt-chain';
 import {getInnerIdx, getOuterIdx} from '../polytool/conversion/pt-misc';
-import {getRules} from '../polytool/pt-rules';
+import {getRules} from '../polytool/conversion/pt-rules';
 import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 category('PolyTool: Chain: parseNotation', () => {

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

@@ -2,7 +2,8 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {before, after, category, expect, test, expectArray, testEvent, delay, expectObject} from '@datagrok-libraries/utils/src/test';
+import {before, after, category, expect, test, expectArray, testEvent, expectObject}
+  from '@datagrok-libraries/utils/src/test';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {
@@ -16,7 +17,7 @@ import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-
 
 import {doPolyToolConvert} from '../polytool/conversion/pt-conversion';
 import {getOverriddenLibrary} from '../polytool/conversion/pt-misc';
-import {getRules} from '../polytool/pt-rules';
+import {getRules} from '../polytool/conversion/pt-rules';
 
 
 import {_package} from '../package-test';

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

@@ -5,6 +5,6 @@ import * as DG from 'datagrok-api/dg';
 import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
 
 import {doPolyToolUnrule} from '../polytool/pt-unrule';
-import {getRules} from '../polytool/pt-rules';
+import {getRules} from '../polytool/conversion/pt-rules';
 
 import {_package} from '../package-test';

package/src/tests/toAtomicLevel-tests.ts

@@ -15,8 +15,8 @@ import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
 import {_package} from '../package-test';
-import {getNewMonomer} from '../polytool/conversion/pt-misc';
-import {getRules, RuleReaction} from '../polytool/pt-rules';
+import {getNewMonomers} from '../polytool/conversion/pt-misc';
+import {getRules, RuleReaction} from '../polytool/conversion/pt-rules';
 
 category('toAtomicLevel', () => {
   let userLibSettings: UserLibSettings;
@@ -78,10 +78,10 @@ category('toAtomicLevel', () => {
     const rules = await getRules(['rules_example.json']);
     const reactionRule = rules.reactionRules.find((r) => r.name == 'GGaz')!;
 
-    const [newSymbol, newMonomer] = getNewMonomer(rdKitModule, systemMonomerLib, reactionRule);
-    expect(newSymbol, reactionRule.name);
+    const [newSymbols, newMonomers] = getNewMonomers(rdKitModule, systemMonomerLib, reactionRule);
+    expect(newSymbols[0], reactionRule.name);
 
-    const mol = rdKitModule.get_mol(newMonomer.molfile);
+    const mol = rdKitModule.get_mol(newMonomers[0].molfile);
     try {
       const molInchi = mol.get_inchi();
       const molInchiKey = rdKitModule.get_inchikey_for_inchi(molInchi);

package/src/polytool/pt-rules.ts

@@ -1,93 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-import * as grok from 'datagrok-api/grok';
-import {ActiveFiles} from '@datagrok-libraries/utils/src/settings/active-files-base';
-
-export const RULES_PATH = 'System:AppData/SequenceTranslator/polytool-rules/';
-export const RULES_STORAGE_NAME = 'Polytool';
-export const RULES_TYPE_LINK = 'link';
-export const RULES_TYPE_REACTION = 'reaction';
-export const RULES_TYPE_HOMODIMER = 'fragmentDuplication';
-export const RULES_TYPE_HETERODIMER = 'differentFragments';
-
-export class RuleInputs extends ActiveFiles {
-  constructor(
-    path: string, userStorageName: string, ext: string,
-    options?: { onValueChanged: (value: string[]) => void }
-  ) {
-    super(path, userStorageName, ext, options);
-  }
-}
-
-export type Rules = {
-  homodimerCode: string | null,
-  heterodimerCode: string | null,
-  linkRules: RuleLink[],
-  reactionRules: RuleReaction[]
-}
-
-export type RuleLink = {
-  code: number,
-  firstMonomer: string,
-  secondMonomer: string,
-  firstSubstitution: string,
-  secondSubstitution: string,
-  firstLinkingGroup: number,
-  secondLinkingGroup: number
-}
-
-export type RuleReaction = {
-  code: number,
-  firstMonomer: string,
-  secondMonomer: string,
-  reaction: string,
-  name: string
-}
-
-export async function getRules(ruleFiles: string[]): Promise<Rules> {
-  const fileSource = new DG.FileSource(RULES_PATH);
-  const linkRules: RuleLink[] = [];
-  const reactionRules: RuleReaction[] = [];
-  const rules: Rules = {homodimerCode: null, heterodimerCode: null, linkRules: linkRules, reactionRules: reactionRules};
-
-  for (let i = 0; i < ruleFiles.length; i++) {
-    const rulesRaw = await fileSource.readAsText(ruleFiles[i].replace(RULES_PATH, ''));
-    const ruleSingle = JSON.parse(rulesRaw);
-    for (let j = 0; j < ruleSingle.length; j++) {
-      if (ruleSingle[j].type !== undefined && ruleSingle[j].code !== undefined) {
-        switch (ruleSingle[j].type) {
-        case RULES_TYPE_LINK: {
-          const rule = ruleSingle[j].monomericSubstitution;
-          rule['code'] = ruleSingle[j].code;
-          linkRules.push(rule);
-          break;
-        }
-        case RULES_TYPE_REACTION: {
-          const rule = ruleSingle[j].monomericSubstitution;
-          rule['code'] = ruleSingle[j].code;
-          reactionRules.push(rule);
-          break;
-        }
-        case RULES_TYPE_HOMODIMER: {
-          if (rules.homodimerCode)
-            grok.shell.warning(`PolyTool: homodimer code is duplicated in rules.`);
-          rules.homodimerCode = ruleSingle[j].code;
-          break;
-        }
-        case RULES_TYPE_HETERODIMER: {
-          if (rules.heterodimerCode)
-            grok.shell.warning(`PolyTool: heterodimer code is duplicated in rules.`);
-          rules.heterodimerCode = ruleSingle[j].code;
-          break;
-        }
-        default:
-          grok.shell.warning(`PolyTool: Unexpected type - '${ruleSingle[j]}'.`);
-          break;
-        }
-      } else {
-        grok.shell.warning('Polytool: rules contain invalid rule');
-      }
-    }
-  }
-
-  return rules;
-}