@datagrok/sequence-translator 1.6.2 → 1.6.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "author": {
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"

package/src/package.ts

@@ -22,7 +22,6 @@ import {polyToolEnumerateHelmUI} from './polytool/pt-enumerate-seq-dialog';
 import {_setPeptideColumn} from './polytool/utils';
 import {PolyToolCsvLibHandler} from './polytool/csv-to-json-monomer-lib-converter';
 import {ITranslationHelper} from './types';
-import {addContextMenuUI} from './utils/context-menu';
 import {PolyToolConvertFuncEditor} from './polytool/pt-convert-editor';
 import {CyclizedNotationProvider} from './utils/cyclized';
 import {getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
@@ -50,7 +49,7 @@ async function initSequenceTranslatorInt(): Promise<void> {
 
 //name: Oligo Toolkit
 //meta.icon: img/icons/toolkit.png
-//meta.browsePath: Oligo
+//meta.browsePath: Peptides | Oligo Toolkit
 //tags: app
 //output: view v
 export async function oligoToolkitApp(): Promise<DG.ViewBase> {
@@ -65,7 +64,7 @@ export async function oligoToolkitApp(): Promise<DG.ViewBase> {
 
 //name: Oligo Translator
 //meta.icon: img/icons/translator.png
-//meta.browsePath: Oligo
+//meta.browsePath: Peptides | Oligo Toolkit
 //tags: app
 //output: view v
 export async function oligoTranslatorApp(): Promise<DG.ViewBase> {
@@ -75,7 +74,7 @@ export async function oligoTranslatorApp(): Promise<DG.ViewBase> {
 
 //name: Oligo Pattern
 //meta.icon: img/icons/pattern.png
-//meta.browsePath: Oligo
+//meta.browsePath: Peptides | Oligo Toolkit
 //tags: app
 //output: view v
 export async function oligoPatternApp(): Promise<DG.ViewBase> {
@@ -85,7 +84,7 @@ export async function oligoPatternApp(): Promise<DG.ViewBase> {
 
 //name: Oligo Structure
 //meta.icon: img/icons/structure.png
-//meta.browsePath: Oligo
+//meta.browsePath: Peptides | Oligo Toolkit
 //tags: app
 //output: view v
 export async function oligoStructureApp(): Promise<DG.ViewBase> {
@@ -210,7 +209,7 @@ export async function getPolyToolConvertEditor(call: DG.FuncCall): Promise<DG.Co
 export async function polyToolConvert2(table: DG.DataFrame,
   seqCol: DG.Column, generateHelm: boolean, chiralityEngine: boolean, rules: string[]
 ): Promise<DG.Column<string>> {
-  const ptConvertRes = await polyToolConvert(seqCol, generateHelm, chiralityEngine, rules);
+  const ptConvertRes = await polyToolConvert(seqCol, generateHelm, false, chiralityEngine, false, rules);
   return ptConvertRes[0];
 }
 
@@ -248,14 +247,6 @@ export async function createMonomerLibraryForPolyTool(file: DG.FileInfo) {
   DG.Utils.download(jsonFileName, jsonFileContent);
 }
 
-// -- Handle context menu --
-
-//name: addContextMenu
-//input: object event
-export function addContextMenu(event: DG.EventData): void {
-  addContextMenuUI(event);
-}
-
 // //name: PolyTool Converter
 // //meta.icon: img/icons/structure.png
 // //meta.browsePath: PolyTool
@@ -282,22 +273,36 @@ export function addContextMenu(event: DG.EventData): void {
 //   }
 // }
 
-//name: PolyTool Enumerator Helm
+//name: HELM Enumerator
 //meta.icon: img/icons/structure.png
-//meta.browsePath: PolyTool
+//meta.browsePath: Peptides | PolyTool
 //tags: app
 export async function ptEnumeratorHelmApp(): Promise<void> {
   await polyToolEnumerateHelmUI();
 }
 
-//name: PolyTool Enumerator Chem
+//name: Chem Enumerator
 //meta.icon: img/icons/structure.png
-//meta.browsePath: PolyTool
+//meta.browsePath: Peptides | PolyTool
 //tags: app
 export async function ptEnumeratorChemApp(): Promise<void> {
   polyToolEnumerateChemUI();
 }
 
+
+//name: Polytool Helm Enumerator dialog
+//input: object cell {nullable: true}
+export async function getPtHelmEnumeratorDialog(cell?: DG.Cell) {
+  return polyToolEnumerateHelmUI(cell);
+}
+
+//name: Polytool Chem Enumerator dialog
+//input: object cell {nullable: true}
+export async function getPtChemEnumeratorDialog(cell?: DG.Cell) {
+  return polyToolEnumerateChemUI(cell);
+}
+
+
 //name: applyNotationProviderForHarmonizedSequence
 //input: column col
 //input: string separator

package/src/polytool/const.ts

@@ -32,6 +32,8 @@ export const PT_WARNING_COLUMN = 'No marcomolecule column chosen!';
 
 export const PT_UI_GET_HELM = 'Get HELM';
 export const PT_UI_ADD_HELM = 'Add HELM column';
+export const PT_UI_LINEARIZE = 'Linearize';
+export const PT_UI_LINEARIZE_TT = 'Make representation linear if possible';
 export const PT_UI_USE_CHIRALITY = 'Chirality engine';
 export const PT_UI_HIGHLIGHT_MONOMERS = 'Highlight monomers';
 export const PT_UI_DIALOG_CONVERSION = 'Poly Tool Conversion';

package/src/polytool/conversion/pt-conversion.ts

@@ -6,13 +6,15 @@ import {Chain} from './pt-chain';
 import {_package} from '../../package';
 
 /** The main PolyTool convert engine. Returns list of Helms. Covered with tests. */
-export function doPolyToolConvert(sequences: string[], rules: Rules, helmHelper: IHelmHelper): string[] {
+export function doPolyToolConvert(sequences: string[], rules: Rules, helmHelper: IHelmHelper): [string[], boolean[]] {
   const helms = new Array<string>(sequences.length);
+  const isLinear = new Array<boolean>(sequences.length);
   for (let i = 0; i < sequences.length; i++) {
     try {
       if (sequences[i] == null) { helms[i] = ''; } else {
         const chain = Chain.fromSeparator(sequences[i], helmHelper);
         chain.applyRules(rules);
+        isLinear[i] = chain.monomersUnderRules.length > 1 || chain.linkagesUnderRules.length > 0 ? false : true;
         helms[i] = chain.getHelm();
       }
     } catch (err: any) {
@@ -21,5 +23,5 @@ export function doPolyToolConvert(sequences: string[], rules: Rules, helmHelper:
       helms[i] = '';
     }
   }
-  return helms;
+  return [helms, isLinear];
 }

package/src/polytool/conversion/pt-rules.ts

@@ -1,5 +1,6 @@
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
 import {ActiveFiles} from '@datagrok-libraries/utils/src/settings/active-files-base';
 import {RulesManager} from './rule-manager';
 
@@ -93,10 +94,15 @@ export class Rules {
   getLinkRulesDf(): DG.DataFrame {
     const length = this.linkRules.length;
     const codeCol = DG.Column.int(NAME_CODE, length);
+    codeCol.setTag('friendlyName', 'Code');
     const firstMonomerCol = DG.Column.string(NAME_FIRST_MONOMERS, length);
+    firstMonomerCol.setTag('friendlyName', 'First monomers');
     const secondMonomerCol = DG.Column.string(NAME_SECOND_MONOMERS, length);
+    secondMonomerCol.setTag('friendlyName', 'Second monomers');
     const firstLinkingGroup = DG.Column.int(NAME_FIRST_LINK, length);
+    firstLinkingGroup.setTag('friendlyName', 'First group');
     const secondLinkingGroup = DG.Column.int(NAME_SECOND_LINK, length);
+    secondLinkingGroup.setTag('friendlyName', 'Second group');
 
     for (let i = 0; i < length; i++) {
       codeCol.set(i, this.linkRules[i].code);
@@ -106,20 +112,29 @@ export class Rules {
       secondLinkingGroup.set(i, this.linkRules[i].secondLinkingGroup);
     }
 
-    return DG.DataFrame.fromColumns([
+    const res = DG.DataFrame.fromColumns([
       codeCol, firstMonomerCol, secondMonomerCol, firstLinkingGroup, secondLinkingGroup
     ]);
+
+    return res;
   }
 
   getSynthesisRulesDf(): DG.DataFrame {
     const length = this.reactionRules.length;
     const codeCol = DG.Column.int(NAME_CODE, length);
+    codeCol.setTag('friendlyName', 'Code');
     const firstMonomerCol = DG.Column.string(NAME_FIRST_MONOMERS, length);
+    firstMonomerCol.setTag('friendlyName', 'First monomers');
     const secondMonomerCol = DG.Column.string(NAME_SECOND_MONOMERS, length);
+    secondMonomerCol.setTag('friendlyName', 'Second monomers');
     const name = DG.Column.string(NAME_REACTION_NAME, length);
+    name.setTag('friendlyName', 'Name');
     const firstReactant = DG.Column.string('firstReactant', length);
+    firstReactant.setTag('friendlyName', 'First reactant');
     const secondReactant = DG.Column.string('secondReactant', length);
+    secondReactant.setTag('friendlyName', 'Second reactant');
     const product = DG.Column.string('product', length);
+    product.setTag('friendlyName', 'Product');
 
     for (let i = 0; i < length; i++) {
       codeCol.set(i, this.reactionRules[i].code);

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

@@ -1,11 +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';
 
+
+const TAB_LINKS = 'Links';
+const TAB_REACTIONS = 'Reactions';
+const TAB_DIMERS = 'Dimers';
+
 export class RulesManager {
   rules: Rules;
   linkRuleDataFrame: DG.DataFrame;
@@ -16,8 +22,6 @@ export class RulesManager {
   homoDimerInput: DG.InputBase;
   heteroDimerInput: DG.InputBase;
 
-  currentTab = '';
-
   // every rule set will have its editor instance
   private static instances: Record<string, RulesManager> = {};
 
@@ -92,20 +96,15 @@ 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) {
     const header = ui.h1(name, 'polytool-grid-header');
     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 +128,10 @@ export class RulesManager {
     }
     const helmHelper = await getHelmHelper();
 
-    const helms = doPolyToolConvert(seqs, this.rules, helmHelper);
+    const [helms, isLinear] = 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 +157,10 @@ export class RulesManager {
     }
     const helmHelper = await getHelmHelper();
 
-    const helms = doPolyToolConvert(seqs, this.rules, helmHelper);
+    const [helms, isLinear] = 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 +176,15 @@ 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]);
+      this.linkRuleDataFrame.plot.grid({showAddNewRowIcon: true}));
     const linkExamples = this.createGridDiv('Examples', await this.getLinkExamplesGrid());
     linksGridDiv.style.width = '50%';
     linkExamples.style.width = '50%';
     const links = ui.divH([linksGridDiv, linkExamples]);
 
-    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%';
@@ -215,6 +210,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/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,13 @@ 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 {getMolHighlight} from '@datagrok-libraries/bio/src/monomer-works/seq-to-molfile';
 import {ChemTags} from '@datagrok-libraries/chem-meta/src/consts';
+import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
 type PolyToolConvertSerialized = {
   generateHelm: boolean;
@@ -99,6 +101,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 +117,7 @@ export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.D
     const div = ui.divV([
       srcColInput,
       generateHelmInput,
+      linearizeInput,
       chiralityEngineInput,
       highlightMonomersInput,
       rulesHeader,
@@ -121,7 +127,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);
       }
@@ -261,8 +270,8 @@ function dealGroups(col: DG.Column<string>): void {
 }
 
 /** 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 +283,7 @@ export async function polyToolConvert(
 
     const table = seqCol.dataFrame;
     const rules = await getRules(ruleFiles);
-    const resList = doPolyToolConvert(seqCol.toList(), rules, helmHelper);
+    const [resList, isLinear] = 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,15 +293,53 @@ 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 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 */ generateHelm, lib);
+      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);
     resMolCol.name = getUnusedName(table, `molfile(${seqCol.name})`);
     resMolCol.semType = DG.SEMTYPE.MOLECULE;