@datagrok/sequence-translator 1.3.5 → 1.3.10

package/src/apps/translator/view/ui.ts

@@ -47,13 +47,12 @@ class TranslatorAppLayout {
     this.moleculeImgDiv.style.marginTop = '12px';
 
     this.outputTableDiv = ui.div([]);
-    this.formatChoiceInput = ui.choiceInput('', DEFAULT_FORMATS.HELM, this.inputFormats, async () => {
+    this.formatChoiceInput = ui.input.choice('', {value: DEFAULT_FORMATS.HELM, items: this.inputFormats, onValueChanged: async () => {
       this.format = this.formatChoiceInput.value;
       this.updateTable();
       await this.updateMolImg();
-    });
-    this.sequenceInputBase = ui.textInput('', DEFAULT_AXOLABS_INPUT,
-      () => { this.onInput.next(); });
+    }});
+    this.sequenceInputBase = ui.input.textArea('', {value: DEFAULT_AXOLABS_INPUT, onValueChanged: () => { this.onInput.next(); }});
 
     this.init();
 
@@ -100,18 +99,12 @@ class TranslatorAppLayout {
 
     const tableControlsManager = new TableControlsManager(this.eventBus);
     const tableControls = tableControlsManager.createUIComponents();
-    const inputFormats = ui.choiceInput(
-      'Input format',
-      DEFAULT_FORMATS.AXOLABS,
-      this.inputFormats,
-      (value: string) => this.eventBus.selectInputFormat(value)
+    const inputFormats = ui.input.choice('Input format', {value: DEFAULT_FORMATS.AXOLABS,
+      items: this.inputFormats, onValueChanged: (input) => this.eventBus.selectInputFormat(input.value)}
     );
 
-    const outputFormats = ui.choiceInput(
-      'Output format',
-      NUCLEOTIDES_FORMAT,
-      getSupportedTargetFormats(this.th),
-      (value: string) => this.eventBus.selectOutputFormat(value)
+    const outputFormats = ui.input.choice('Output format', {value: NUCLEOTIDES_FORMAT,
+      items: getSupportedTargetFormats(this.th), onValueChanged: (input) => this.eventBus.selectOutputFormat(input.value)}
     );
     const convertBulkButton = this.createConvertBulkButton();
 
@@ -169,7 +162,7 @@ class TranslatorAppLayout {
     if (outputFormat === NUCLEOTIDES_FORMAT || outputFormat === DEFAULT_FORMATS.HELM) {
       translatedColumn.semType = DG.SEMTYPE.MACROMOLECULE;
       const units = outputFormat == NUCLEOTIDES_FORMAT ? NOTATION.FASTA : NOTATION.HELM;
-      translatedColumn.setTag(DG.TAGS.UNITS, units);
+      translatedColumn.meta.units = units;
       const seqHandler = SeqHandler.forColumn(translatedColumn as DG.Column<string>);
       const setUnits = outputFormat == NUCLEOTIDES_FORMAT ? SeqHandler.setUnitsToFastaColumn :
         SeqHandler.setUnitsToHelmColumn;
@@ -381,16 +374,13 @@ class TableInputManager {
   private createTableInput(): DG.InputBase<DG.DataFrame | null> {
     const currentlySelectedTable = this.eventBus.getSelectedTable();
 
-    const tableInput = ui.tableInput(
-      'Table',
-      currentlySelectedTable,
-      this.availableTables,
-      (table: DG.DataFrame) => {
+    const tableInput = ui.input.table('Table', {value: currentlySelectedTable!, items: this.availableTables,
+      onValueChanged: (input) => {
         // WARNING: non-null check necessary to prevent resetting columns to
         // null upon handling onTableAdded
-        if (table !== null && table instanceof DG.DataFrame)
-          this.eventBus.selectTable(table);
-      });
+        if (input.value !== null)
+          this.eventBus.selectTable(input.value);
+      }});
     return tableInput;
   }
 
@@ -459,10 +449,8 @@ class ColumnInputsManager {
     const selectedColumnName = matchingColumnName ? matchingColumnName : columnNames[0];
     this.selectColumnIfTableNotNull(selectedTable, selectedColumnName, columnLabel);
 
-    const input = ui.choiceInput(
-      `${columnLabel}`,
-      selectedColumnName, columnNames,
-      (colName: string) => this.selectColumnIfTableNotNull(selectedTable, colName, columnLabel)
+    const input = ui.input.choice(`${columnLabel}`, {value: selectedColumnName, items: columnNames,
+      onValueChanged: (input) => this.selectColumnIfTableNotNull(selectedTable, input.value, columnLabel)}
     );
 
     return input;

package/src/package.ts

@@ -16,10 +16,12 @@ import {demoOligoPatternUI, demoOligoStructureUI, demoOligoTranslatorUI} from '.
 import {getExternalAppViewFactories} from './plugins/mermade';
 
 //polytool specific
-import {getPolyToolConversionDialog, getPolyToolEnumerationDialog} from './polytool/pt-dialog';
+import {getPolyToolConversionDialog} from './polytool/pt-dialog';
 import {_setPeptideColumn} from './polytool/utils';
 import {PolyToolCsvLibHandler} from './polytool/csv-to-json-monomer-lib-converter';
 import {ITranslationHelper} from './types';
+import {polyToolEnumerateHelmUI, polyToolEnumerateChemUI} from './polytool/pt-ui';
+import {addContextMenuUI} from './utils/context-menu';
 
 export const _package: OligoToolkitPackage = new OligoToolkitPackage();
 
@@ -163,19 +165,20 @@ export async function polyToolConvert(): Promise<void> {
   }
 }
 
-//top-menu: Bio | Convert | PolyTool-Enumerate
-//name: polyToolEnumerate
+//top-menu: Bio | Convert | PolyTool-Enumerate HELM
+//name: polyToolEnumerateHelm
 //description: Perform cyclization of polymers
-export async function polyToolEnumerate(): Promise<void> {
-  let dialog: DG.Dialog;
-  try {
-    dialog = await getPolyToolEnumerationDialog();
-    dialog.show();
-  } catch (err: any) {
-    grok.shell.warning('To run PolyTool Enumeration, sketch the macromolecule and select monomers to vary');
-  }
+export async function polyToolEnumerateHelm(): Promise<void> {
+  polyToolEnumerateHelmUI();
 }
 
+// //top-menu: Bio | Convert | PolyTool-Enumerate Chem
+// //name: polyToolEnumerateChem
+// //description: Perform cyclization of polymers
+// export async function polyToolEnumerateChem(): Promise<void> {
+//   polyToolEnumerateChemUI();
+// }
+
 //name: polyToolColumnChoice
 //input: dataframe df [Input data table]
 //input: column macroMolecule
@@ -194,3 +197,41 @@ export async function createMonomerLibraryForPolyTool(file: DG.FileInfo) {
   const jsonFileContent = JSON.stringify(libObject, null, 2);
   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
+// //tags: app
+// //output: view v
+// export async function ptConverterApp(): Promise<DG.ViewBase> {
+//   const view = await getSpecifiedAppView(APP_NAME.STRUCTURE);
+//   return view;
+// }
+
+// //name: PolyTool Enumerator Helm
+// //meta.icon: img/icons/structure.png
+// //meta.browsePath: PolyTool
+// //tags: app
+// //output: view v
+// export async function ptEnumeratorHelmApp(): Promise<DG.ViewBase> {
+//   const view = await getSpecifiedAppView(APP_NAME.STRUCTURE);
+//   return view;
+// }
+
+// //name: PolyTool Enumerator Chem
+// //meta.icon: img/icons/structure.png
+// //meta.browsePath: PolyTool
+// //tags: app
+// //output: view v
+// export async function ptEnumeratorChemApp(): Promise<DG.ViewBase> {
+//   const view = await getSpecifiedAppView(APP_NAME.STRUCTURE);
+//   return view;
+// }

package/src/plugins/mermade.ts

@@ -41,7 +41,7 @@ export async function getExternalAppViewFactories(
 }
 
 function getMerMadeParameters(th: ITranslationHelper): { [name: string]: any } {
-  const base = ui.textInput('', '');
+  const base = ui.input.textArea('', {value: ''});
   const input = new ColoredTextInput(base, th.highlightInvalidSubsequence);
 
   return {

package/src/polytool/pt-conversion.ts

@@ -10,7 +10,7 @@ export const RULES_DIMER = '(#2)';
 export const RULES_HETERODIMER = '($2)';
 
 function addCommonTags(col: DG.Column): void {
-  col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
+  col.semType = DG.SEMTYPE.MACROMOLECULE;
   col.setTag('aligned', ALIGNMENT.SEQ);
   col.setTag('alphabet', ALPHABET.PT);
 }
@@ -290,7 +290,7 @@ export async function addTransformedColumn(
   const targetHelmCol = DG.Column.fromList('string', helmColName, targetList);
 
   addCommonTags(targetHelmCol);
-  targetHelmCol.setTag('units', NOTATION.HELM);
+  targetHelmCol.meta.units = NOTATION.HELM;
 
   if (addHelm) {
     targetHelmCol.setTag('cell.renderer', 'helm');

package/src/polytool/pt-dialog.ts

@@ -3,12 +3,20 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import wu from 'wu';
+
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {HelmAtom} from '@datagrok-libraries/bio/src/helm/types';
+
 import {RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
 import {addTransformedColumn} from './pt-conversion';
 
 import {handleError} from './utils';
-import {getLibrariesList, HelmInput, getEnumeration} from './pt-enumeration';
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {defaultErrorHandler} from '../utils/err-info';
+import {getLibrariesList} from './utils';
+import {getEnumerationHelm, PT_HELM_EXAMPLE} from './pt-enumeration-helm';
+import {getEnumerationChem, PT_CHEM_EXAMPLE} from './pt-enumeration-chem';
 
 const PT_ERROR_DATAFRAME = 'No dataframe with macromolecule columns open';
 const PT_WARNING_COLUMN = 'No marcomolecule column chosen!';
@@ -25,15 +33,15 @@ export async function getPolyToolConversionDialog(): Promise<DG.Dialog> {
   if (!targetColumns)
     throw new Error(PT_ERROR_DATAFRAME);
 
-  const targetColumnInput = ui.columnInput(
-    'Column', grok.shell.t, targetColumns[0], null,
-    {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE}
-  );
+  const targetColumnInput = ui.input.column('Column', {
+    table: grok.shell.t, value: targetColumns[0],
+    filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE
+  });
 
-  const generateHelmChoiceInput = ui.boolInput(PT_UI_GET_HELM, true);
+  const generateHelmChoiceInput = ui.input.bool(PT_UI_GET_HELM, {value: true});
   ui.tooltip.bind(generateHelmChoiceInput.root, PT_UI_ADD_HELM);
 
-  const chiralityEngineInput = ui.boolInput(PT_UI_USE_CHIRALITY, false);
+  const chiralityEngineInput = ui.input.bool(PT_UI_USE_CHIRALITY, {value: false});
   const ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json');
   const rulesHeader = ui.inlineText([PT_UI_RULES_USED]);
   ui.tooltip.bind(rulesHeader, 'Add or specify rules to use');
@@ -74,44 +82,117 @@ export async function getPolyToolConversionDialog(): Promise<DG.Dialog> {
   return dialog;
 }
 
-export async function getPolyToolEnumerationDialog(): Promise<DG.Dialog> {
-  const helmInput = await HelmInput.init();
+export async function getPolyToolEnumerationHelmDialog(cell?: DG.Cell): Promise<DG.Dialog> {
+  const [libList, helmHelper] = await Promise.all([
+    getLibrariesList(), getHelmHelper()]);
+
+  const helmValue = cell ? cell.value : PT_HELM_EXAMPLE;
 
-  const libList = await getLibrariesList();
-  const screenLibrary = ui.choiceInput('Library to use', null, libList);
+  const helmInput = helmHelper.createHelmInput('Macromolecule', {value: helmValue});
+  const screenLibrary = ui.input.choice('Library to use', {value: null, items: libList});
 
+  helmInput.input.setAttribute('style', `min-width:250px!important;`);
   screenLibrary.input.setAttribute('style', `min-width:250px!important;`);
 
   const div = ui.div([
-    helmInput.getDiv(),
+    helmInput.root,
     screenLibrary.root
   ]);
 
+  // Displays the molecule from a current cell (monitors changes)
   const cccSubs = grok.events.onCurrentCellChanged.subscribe(() => {
     const cell = grok.shell.tv.dataFrame.currentCell;
 
-    if (cell.column.semType === DG.SEMTYPE.MACROMOLECULE && cell.column.tags[DG.TAGS.UNITS] === NOTATION.HELM)
-      helmInput.setHelmString(cell.value);
+    if (cell.column.semType === DG.SEMTYPE.MACROMOLECULE && cell.column.meta.units === NOTATION.HELM)
+      helmInput.stringValue = cell.value;
   });
 
   const dialog = ui.dialog(PT_UI_DIALOG_ENUMERATION)
     .add(div)
     .onOK(async () => {
       try {
-        const helmString = helmInput.getHelmString();
-        const helmSelections = helmInput.getHelmSelections();
+        const helmString = helmInput.stringValue;
+        const helmSelections: number[] = wu.enumerate<HelmAtom>(helmInput.value.atoms)
+          .filter(([a, aI]) => a.highlighted)
+          .map(([a, aI]) => aI).toArray();
         if (helmString === undefined || helmString === '') {
           grok.shell.warning('PolyTool: no molecule was provided');
         } else if (helmSelections === undefined || helmSelections.length < 1) {
           grok.shell.warning('PolyTool: no selection was provided');
         } else {
-          const molecules = await getEnumeration(helmString, helmSelections, screenLibrary.value!);
+          const molecules = await getEnumerationHelm(helmString, helmSelections, screenLibrary.value!);
           const molCol = DG.Column.fromStrings('Enumerated', molecules);
           const df = DG.DataFrame.fromColumns([molCol]);
           grok.shell.addTableView(df);
         }
       } catch (err: any) {
+        defaultErrorHandler(err);
+      } finally {
+        cccSubs.unsubscribe();
+      }
+    }).onCancel(() => {
+      cccSubs.unsubscribe();
+    });
+
+  return dialog;
+}
+
+export async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dialog> {
+  const [libList, helmHelper] = await Promise.all([
+    getLibrariesList(), getHelmHelper()]);
+
+  let molValue = PT_CHEM_EXAMPLE;//cell ? cell.value : PT_CHEM_EXAMPLE;
+  const molInput = new DG.chem.Sketcher(DG.chem.SKETCHER_MODE.EXTERNAL);
+  molInput.syncCurrentObject = false;
+  // sketcher.setMolFile(col.tags[ALIGN_BY_SCAFFOLD_TAG]);
+  molInput.onChanged.subscribe((_: any) => {
+    molValue = molInput.getMolFile();
+    // col.tags[ALIGN_BY_SCAFFOLD_TAG] = molFile;
+    // col.temp[ALIGN_BY_SCAFFOLD_TAG] = molFile;
+    // col.dataFrame?.fireValuesChanged();
+  });
+  molInput.root.classList.add('ui-input-editor');
+  molInput.root.style.marginTop = '3px';
+  molInput.setMolFile(molValue);
+
+  //const helmInput = helmHelper.createHelmInput('Macromolecule', {value: helmValue});
+  const screenLibrary = ui.input.choice('Library to use', {value: null, items: libList});
 
+  molInput.root.setAttribute('style', `min-width:250px!important;`);
+  molInput.root.setAttribute('style', `max-width:250px!important;`);
+  screenLibrary.input.setAttribute('style', `min-width:250px!important;`);
+
+  const div = ui.div([
+    molInput.root,
+    screenLibrary.root
+  ]);
+
+  const cccSubs = grok.events.onCurrentCellChanged.subscribe(() => {
+    const cell = grok.shell.tv.dataFrame.currentCell;
+
+    if (cell.column.semType === DG.SEMTYPE.MOLECULE)
+      molInput.setValue(cell.value);
+  });
+
+  // Displays the molecule from a current cell (monitors changes)
+  const dialog = ui.dialog(PT_UI_DIALOG_ENUMERATION)
+    .add(div)
+    .onOK(async () => {
+      try {
+        const molString = molInput.getMolFile();
+
+        if (molString === undefined || molString === '') {
+          grok.shell.warning('PolyTool: no molecule was provided');
+        } else if (!molString.includes('R#')) {
+          grok.shell.warning('PolyTool: no R group was provided');
+        } else {
+          const molecules = await getEnumerationChem(molString, screenLibrary.value!);
+          const molCol = DG.Column.fromStrings('Enumerated', molecules);
+          const df = DG.DataFrame.fromColumns([molCol]);
+          grok.shell.addTableView(df);
+        }
+      } catch (err: any) {
+        defaultErrorHandler(err);
       } finally {
         cccSubs.unsubscribe();
       }

package/src/polytool/pt-enumeration-chem.ts

@@ -0,0 +1,105 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {getAvailableMonomers, getAvailableMonomerMols} from './utils';
+import {RDModule, RDMol} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+
+export const PT_CHEM_EXAMPLE = `
+
+
+ 22 24  0  0  0  0  0  0  0  0999 V2000
+    0.3128   -0.7509    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    0.3128    0.0740    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.4054   -1.1623    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.1081   -0.7509    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.4054    0.4877    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.1081    0.0740    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.8175   -1.1623    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.0222    0.4877    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.8175    0.4877    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.5292   -0.7509    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.0222    1.3127    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.7227    1.7263    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.4054   -1.9896    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.5292    0.0740    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    2.4544    1.3127    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.7406    0.0740    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.0222   -1.1623    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0
+    2.4544    0.4877    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.8175   -1.9896    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.2453    0.4877    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0
+    3.1670    1.7285    0.0000 R#  0  0  0  0  0  0  0  0  0  0  0  0
+    1.7149    2.5513    0.0000 R#  0  0  0  0  0  0  0  0  0  0  0  0
+  2  1  2  0  0  0  0
+  3  1  1  0  0  0  0
+  4  3  1  0  0  0  0
+  5  2  1  0  0  0  0
+  6  5  1  0  0  0  0
+  7  4  1  0  0  0  0
+  8  2  1  0  0  0  0
+  9  6  1  0  0  0  0
+ 10  7  2  0  0  0  0
+ 11  8  2  0  0  0  0
+ 12 11  1  0  0  0  0
+ 13  3  2  0  0  0  0
+ 14  9  2  0  0  0  0
+ 15 18  1  0  0  0  0
+ 16  8  1  0  0  0  0
+ 17  1  1  0  0  0  0
+ 18 16  2  0  0  0  0
+ 19  7  1  0  0  0  0
+ 20 14  1  0  0  0  0
+  6  4  2  0  0  0  0
+ 15 12  2  0  0  0  0
+ 14 10  1  0  0  0  0
+ 15 21  1  0  0  0  0
+ 12 22  1  0  0  0  0
+M  RGP  2  21   1  22   2
+M  END`;
+
+export async function getEnumerationChem(molString: string, screenLibrary: string):
+  Promise<string[]> {
+  const variableMonomers = await getAvailableMonomers(screenLibrary);
+  const variableMols = await getAvailableMonomerMols(screenLibrary);
+
+	const idx = molString.indexOf('M  RGP');
+	const rCount = parseInt(molString.slice(idx + 6, idx + 9)); //extracting from molfile positions
+  const size = 1 * variableMonomers.length;
+  const enumerations = new Array<string>(size);
+
+	const rdkitModule: RDModule = await grok.functions.call('Chem:getRdKitModule');
+  const molScaffold: RDMol = rdkitModule.get_mol(molString);
+  const smiScaffold = molScaffold.get_smiles();
+  molScaffold.delete();
+
+  const smilesSubsts = new Array<string>(variableMonomers.length);
+
+  for (let i = 0; i < variableMonomers.length; i++) {
+			
+    const name = variableMonomers[i];
+    const molBlock = variableMols[name];
+    const molSubst: RDMol = rdkitModule.get_mol(molBlock);
+    smilesSubsts[i] = molSubst.get_smiles();
+    molSubst.delete();
+  }
+
+	//TODO: get for all R groups
+  for (let i = 0; i < 1; i++) {
+    for (let j = 0; j < variableMonomers.length; j++) {
+      try {
+        const smiResRaw = `${smiScaffold}.${smilesSubsts[j]}`.replaceAll('[1*]C', 'C([1*])').replaceAll('[1*]c', 'c([1*])').replaceAll('[1*]O', 'O([1*])').replaceAll('[1*]N', 'N([1*])');
+        const smiRes = `${smiResRaw}`.replaceAll('([1*])', '9').replaceAll('[1*]', '9');
+        const molRes: RDMol = rdkitModule.get_mol(smiRes);
+
+        enumerations[i * variableMonomers.length + j] = molRes.get_v3Kmolblock();
+        molRes.delete();
+      } 
+      catch(err:any) {
+        enumerations[i * variableMonomers.length + j] = '';
+      }
+		}
+  }
+
+  return enumerations;
+}

package/src/polytool/pt-enumeration-helm.ts

@@ -0,0 +1,22 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import {Chain} from './pt-conversion';
+import {getAvailableMonomers} from './utils'
+
+export const PT_HELM_EXAMPLE = 'PEPTIDE1{[R].[F].[T].[G].[H].[F].[G].[A].[A].[Y].[P].[E].[NH2]}$$$$';
+
+export async function getEnumerationHelm(helmString: string, helmSelections: number[], screenLibrary: string):
+  Promise<string[]> {
+  const variableMonomers = await getAvailableMonomers(screenLibrary);
+  const chain: Chain = Chain.fromHelm(helmString);
+  const size = helmSelections.length * variableMonomers.length;
+  const enumerations = new Array<string>(size);
+
+  for (let i = 0; i < helmSelections.length; i++) {
+    for (let j = 0; j < variableMonomers.length; j++)
+      enumerations[i * variableMonomers.length + j] = chain.getHelmChanged(helmSelections[i], variableMonomers[j]);
+  }
+
+  return enumerations;
+}

package/src/polytool/pt-ui.ts

@@ -0,0 +1,25 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+
+import {getPolyToolEnumerationHelmDialog, getPolyToolEnumerationChemDialog} from './pt-dialog';
+
+export function polyToolEnumerateHelmUI(cell?: DG.Cell): void {
+  getPolyToolEnumerationHelmDialog(cell)
+    .then((dialog) => {
+      dialog.show({resizable: true});
+    })
+    .catch((_err: any) => {
+      grok.shell.warning('To run PolyTool Enumeration, sketch the macromolecule and select monomers to vary');
+    });
+}
+
+export function polyToolEnumerateChemUI(cell?: DG.Cell): void {
+  getPolyToolEnumerationChemDialog(cell)
+    .then((dialog) => {
+      dialog.show({resizable: true});
+    })
+    .catch((_err: any) => {
+      grok.shell.warning('To run PolyTool Enumeration, sketch the molecule and specify the R group to vary');
+    });
+}

package/src/polytool/utils.ts

@@ -2,19 +2,27 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import {_package} from '../package';
 
+import {_package} from '../package';
 import {ALPHABET, ALIGNMENT, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {OrgType} from '@datagrok-libraries/bio/src/helm/types';
+
+import {
+  IMonomerLibFileManager, IMonomerLibHelper
+} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+declare const org: OrgType;
+const LIB_PATH = 'System:AppData/Bio/monomer-libraries/';
 
 export function _setPeptideColumn(col: DG.Column): void {
   addCommonTags(col);
-  col.setTag('units', NOTATION.SEPARATOR);
+  col.meta.units = NOTATION.SEPARATOR;
   col.setTag('separator', '-');
   // col.setTag('cell.renderer', 'sequence');
 }
 
 function addCommonTags(col: DG.Column<any>) {
-  col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
+  col.semType = DG.SEMTYPE.MACROMOLECULE;
   col.setTag('aligned', ALIGNMENT.SEQ);
   col.setTag('alphabet', ALPHABET.PT);
 }
@@ -25,3 +33,26 @@ export function handleError(err: any): void {
   grok.shell.error(errMsg);
   _package.logger.error(err.message, undefined, stack);
 }
+
+export async function getAvailableMonomers(screenLibrary: string): Promise<string[]> {
+  const monomerLibHelper: IMonomerLibHelper = await grok.functions.call('Bio:getMonomerLibHelper', {});
+  const monomerLib = await monomerLibHelper.readLibrary(LIB_PATH, screenLibrary);
+  //NOTICE: works with Peptides only
+  return monomerLib.getMonomerSymbolsByType('PEPTIDE');
+}
+
+export async function getAvailableMonomerMols(screenLibrary: string): Promise<{[monomerSymbol: string]: string}> {
+  const monomerLibHelper: IMonomerLibHelper = await grok.functions.call('Bio:getMonomerLibHelper', {});
+  const monomerLib = await monomerLibHelper.readLibrary(LIB_PATH, screenLibrary);
+  const monomers = monomerLib.getMonomerSymbolsByType('PEPTIDE');
+  const mols = new Array<string>(monomers.length);
+
+  //NOTICE: works with Peptides only
+  return monomerLib.getMonomerMolsByPolymerType('PEPTIDE')!;
+}
+
+export async function getLibrariesList(): Promise<string[]> {
+  const monomerLibHelper: IMonomerLibHelper = await grok.functions.call('Bio:getMonomerLibHelper', {});
+  const monomerFileManager: IMonomerLibFileManager = await monomerLibHelper.getFileManager();
+  return monomerFileManager.getValidLibraryPaths();
+}

package/src/utils/context-menu.ts

@@ -0,0 +1,57 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+
+import {defaultErrorHandler} from './err-info';
+import {_package, addContextMenu} from '../package';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {polyToolEnumerateHelmUI} from '../polytool/pt-ui';
+
+export type SequenceTranslatorWindowType = Window & {
+  $sequenceTranslator?: {
+    contextMenuError?: any
+  },
+};
+declare const window: SequenceTranslatorWindowType;
+
+export function addContextMenuUI(event: DG.EventData): void {
+  try {
+    const item = event.args.item;
+    if (item) {
+      const menu: DG.Menu = event.args.menu;
+      if (item instanceof DG.GridCell || item.constructor.name == 'GridCell') {
+        const gridCell: DG.GridCell = item;
+        if (addContextMenuForCell(gridCell, menu))
+          event.preventDefault();
+      }
+    }
+  } catch (err: any) {
+    defaultErrorHandler(err);
+    if (!window.$sequenceTranslator) window.$sequenceTranslator = {};
+    window.$sequenceTranslator.contextMenuError = err;
+  }
+}
+
+function addContextMenuForCell(gridCell: DG.GridCell, menu: DG.Menu): boolean {
+  const logPrefix: string = `ST: addContextMenuForCell()`;
+  _package.logger.debug(`${logPrefix}, start`);
+
+  const polyToolEnumerate = () => {
+    polyToolEnumerateHelmUI(gridCell.cell);
+  };
+
+  if (gridCell && gridCell.tableColumn) {
+    switch (gridCell.tableColumn.semType) {
+    case DG.SEMTYPE.MACROMOLECULE: {
+      const sh = SeqHandler.forColumn(gridCell.tableColumn);
+      if (sh.notation === NOTATION.HELM) {
+        menu
+          .item('PolyTool-Enumerate', polyToolEnumerate);
+        true;
+      }
+    }
+    }
+  }
+  return false;
+}

package/src/utils/err-info.ts

@@ -0,0 +1,13 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+
+import {_package} from '../package';
+
+export function defaultErrorHandler(err: any): void {
+  const [errMsg, errStack] = errInfo(err);
+  _package.logger.error(errMsg, undefined, errStack);
+  grok.shell.error(errMsg);
+}