@datagrok/sequence-translator 1.3.14 → 1.3.15

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

@@ -0,0 +1,116 @@
+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 {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';
+
+/** Inputs of polyToolConvert2 package function */
+export enum P {
+  table = 'table',
+  seqCol = 'seqCol',
+  generateHelm = 'generateHelm',
+  chiralityEngine = 'chiralityEngine',
+  rules = 'rules'
+}
+
+type PolyToolConvertInputs = {
+  table: DG.InputBase<DG.DataFrame | null>;
+  seqCol: DG.InputBase<DG.Column | null>;
+  generateHelm: DG.InputBase<boolean>;
+  chiralityEngine: DG.InputBase<boolean>;
+  rules: { header: HTMLElement, form: HTMLDivElement };
+}
+
+export class PolyToolConvertFuncEditor {
+  private inputs: PolyToolConvertInputs;
+  private readonly ruleInputs: RuleInputs;
+
+  protected constructor(
+    private readonly call: DG.FuncCall,
+  ) {
+    this.ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json');
+  }
+
+  private async initInputs(): Promise<void> {
+    const getParam = (pName: string) => this.call.inputParams[pName];
+
+    this.inputs = {
+      table: (() => {
+        const p = getParam(P.table);
+        return ui.input.table(p.property.caption, {value: p.value});
+      })(),
+      seqCol: (() => {
+        const p = getParam(P.seqCol);
+        return ui.input.column(p.property.caption, {value: p.value, table: p.value.dataFrame});
+      })(),
+      generateHelm: ui.input.forProperty(getParam(P.generateHelm).property),
+      chiralityEngine: ui.input.forProperty(getParam(P.chiralityEngine).property),
+      rules: {
+        header: ui.inlineText([PT_UI_RULES_USED]),
+        form: await this.ruleInputs.getForm(),
+      }
+    };
+  }
+
+  static async create(call: DG.FuncCall): Promise<PolyToolConvertFuncEditor> {
+    const editor = new PolyToolConvertFuncEditor(call);
+    await editor.initInputs();
+    return editor;
+  }
+
+  // -- Params --
+
+  private async getParams(): Promise<{ [p: string]: any }> {
+    return {
+      table: this.inputs.table.value!,
+      seqCol: this.inputs.seqCol.value!,
+      generateHelm: this.inputs.generateHelm.value,
+      chiralityEngine: this.inputs.chiralityEngine.value,
+      rules: await this.ruleInputs.getActive(),
+    };
+  }
+
+  public async showDialog(): Promise<DG.Column<string>> {
+    const formDiv = ui.div([
+        this.inputs.table,
+        this.inputs.seqCol,
+        this.inputs.generateHelm,
+        this.inputs.chiralityEngine,
+        this.inputs.rules.header,
+        this.inputs.rules.form,
+      ],
+      {style: {minWidth: '320px'}});
+
+    return new Promise((resolve, reject) => {
+      ui.dialog({title: PT_UI_DIALOG_CONVERSION})
+        .add(formDiv)
+        .onOK(async () => {
+          const callParams = await this.getParams();
+          const res = (await this.call.func.prepare(callParams).call(true)).getOutputParamValue() as DG.Column<string>;
+          resolve(res);
+        })
+        .onCancel(() => { reject(new Error('Cancelled by user')); })
+        .show();
+    });
+  }
+
+  // -- UI --
+
+  public widget(): DG.Widget {
+    throw new Error('not implemented');
+
+    // const inputsForm = ui.inputs(Object.entries(this.inputs)
+    //   .filter(([inputName, _input]) => !['table', 'sequence'].includes(inputName))
+    //   .map(([_inputName, input]) => input));
+    // const doBtn = ui.button('Convert', () => {
+    //   (async () => {
+    //     const callParams = this.getParams();
+    //     await this.call.func.prepare(callParams).call(true);
+    //   })()
+    //     .catch((err: any) => { defaultErrorHandler(err, true); });
+    // });
+    // return DG.Widget.fromRoot(ui.divV([inputsForm, ui.div(doBtn)]));
+  }
+}

package/src/polytool/pt-dialog.ts

@@ -4,16 +4,19 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import $ from 'cash-dom';
+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 {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
-import {RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
-import {addTransformedColumn} from './pt-conversion';
-
-import {handleError} from './utils';
+import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {doPolyToolConvert} from './pt-conversion';
 import {defaultErrorHandler} from '../utils/err-info';
 import {getLibrariesList} from './utils';
 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_RULES_USED, PT_UI_USE_CHIRALITY, PT_WARNING_COLUMN
@@ -31,100 +34,126 @@ export function polyToolEnumerateChemUI(cell?: DG.Cell): void {
     });
 }
 
-export async function getPolyToolConversionDialog(targetCol?: DG.Column): Promise<DG.Dialog> {
-  const targetColumns = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
-  if (!targetColumns)
-    throw new Error(PT_ERROR_DATAFRAME);
-
-  const targetColumnInput = ui.input.column('Column', {
-    table: grok.shell.t, value: targetColumns[0],
-    filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE
-  });
-
-  targetColumnInput.value = targetCol ? targetCol : targetColumnInput.value;
-
-  const generateHelmChoiceInput = ui.input.bool(PT_UI_GET_HELM, {value: true});
-  ui.tooltip.bind(generateHelmChoiceInput.root, PT_UI_ADD_HELM);
-
-  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');
-  const rulesForm = await ruleInputs.getForm();
-
-  const div = ui.div([
-    targetColumnInput,
-    generateHelmChoiceInput,
-    chiralityEngineInput,
-    rulesHeader,
-    rulesForm
-  ]);
-
-  const dialog = ui.dialog(PT_UI_DIALOG_CONVERSION)
-    .add(div)
-    .onOK(async () => {
-      const pi = DG.TaskBarProgressIndicator.create('PolyTool converting');
-      try {
-        const sequencesCol = targetColumnInput.value;
-        if (!sequencesCol) {
-          grok.shell.warning(PT_WARNING_COLUMN);
-          return;
-        }
+export async function polyToolConvertUI(): Promise<void> {
+  let dialog: DG.Dialog;
+  try {
+    dialog = await getPolyToolConvertDialog();
+    dialog.show();
+  } catch (err: any) {
+    const [errMsg, errStack] = errInfo(err);
+    grok.shell.warning('To run PolyTool Conversion, open a dataframe with macromolecules');
+    _package.logger.error(errMsg, undefined, errStack);
+  }
+}
+
+export async function getPolyToolConvertDialog(targetCol?: DG.Column): Promise<DG.Dialog> {
+  const subs: Unsubscribable[] = [];
+  const destroy = () => {
+    for (const sub of subs) sub.unsubscribe();
+  };
+  try {
+    const targetColumns = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
+    if (!targetColumns)
+      throw new Error(PT_ERROR_DATAFRAME);
+
+    const targetColumnInput = ui.input.column('Column', {
+      table: grok.shell.t, value: targetColumns[0],
+      filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE
+    });
+
+    targetColumnInput.value = targetCol ? targetCol : targetColumnInput.value;
+
+    const generateHelmChoiceInput = ui.input.bool(PT_UI_GET_HELM, {value: true});
+    ui.tooltip.bind(generateHelmChoiceInput.root, PT_UI_ADD_HELM);
 
-        const files = await ruleInputs.getActive();
+    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');
+    const rulesForm = await ruleInputs.getForm();
 
-        addTransformedColumn(sequencesCol!,
-          generateHelmChoiceInput.value!,
-          files,
-          chiralityEngineInput.value!);
+    const div = ui.div([
+      targetColumnInput,
+      generateHelmChoiceInput,
+      chiralityEngineInput,
+      rulesHeader,
+      rulesForm
+    ]);
+
+
+    const exec = async (): Promise<void> => {
+      try {
+        const ruleFileList = await ruleInputs.getActive();
+        await polyToolConvert(targetColumnInput.value!, generateHelmChoiceInput.value!, chiralityEngineInput.value!, ruleFileList);
       } catch (err: any) {
-        handleError(err);
-      } finally {
-        pi.close();
+        defaultErrorHandler(err);
       }
-    });
-
-  return dialog;
+    };
+
+    const dialog = ui.dialog(PT_UI_DIALOG_CONVERSION)
+      .add(div)
+      .onOK(() => { exec(); });
+    subs.push(dialog.onClose.subscribe(() => {
+      destroy();
+    }));
+
+    return dialog;
+  } catch (err: any) {
+    destroy(); // on failing to build a dialog
+    throw err;
+  }
 }
 
 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();
-  });
-  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 () => {
+  const subs: Unsubscribable[] = [];
+  const destroy = () => {
+    for (const sub of subs) sub.unsubscribe();
+  };
+  try {
+
+    const [libList, helmHelper] = await Promise.all([
+      getLibrariesList(), getHelmHelper()]);
+
+    const molStr = (cell && cell.rowIndex >= 0) ? cell.value : PT_CHEM_EXAMPLE;//cell ? cell.value : PT_CHEM_EXAMPLE;
+    let molfileValue: string = await (async (): Promise<string> => {
+      if (DG.chem.isMolBlock(molStr)) return molStr;
+      return (await grok.functions.call('Chem:convertMolNotation', {
+        molecule: molStr,
+        sourceNotation: cell?.column.getTag(DG.TAGS.UNITS) ?? DG.chem.Notation.Unknown,
+        targetNotation: DG.chem.Notation.MolBlock,
+      }));
+    })();
+
+    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) => {
+      molfileValue = molInput.getMolFile();
+    });
+    molInput.root.classList.add('ui-input-editor');
+    molInput.root.style.marginTop = '3px';
+    molInput.setMolFile(molfileValue);
+
+    //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
+    ]);
+
+    subs.push(grok.events.onCurrentCellChanged.subscribe(() => {
+      const cell = grok.shell.tv.dataFrame.currentCell;
+
+      if (cell.column.semType === DG.SEMTYPE.MOLECULE)
+        molInput.setValue(cell.value);
+    }));
+
+    const exec = async (): Promise<void> => {
       try {
         const molString = molInput.getMolFile();
 
@@ -140,12 +169,63 @@ async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dial
         }
       } catch (err: any) {
         defaultErrorHandler(err);
-      } finally {
-        cccSubs.unsubscribe();
       }
-    }).onCancel(() => {
-      cccSubs.unsubscribe();
-    });
+    };
+
+    // Displays the molecule from a current cell (monitors changes)
+    const dialog = ui.dialog(PT_UI_DIALOG_ENUMERATION)
+      .add(div)
+      .onOK(() => {
+        exec().finally(() => { destroy(); });
+      })
+      .onCancel(() => {
+        destroy();
+      });
+    subs.push(dialog.onClose.subscribe(() => {
+      destroy();
+    }));
+    return dialog;
+  } catch (err: any) {
+    destroy();
+    throw err;
+  }
+}
 
-  return dialog;
+/** Returns Helm and molfile columns.  */
+export async function polyToolConvert(
+  seqCol: DG.Column<string>, generateHelm: boolean, chiralityEngine: boolean, ruleFiles: string[]
+): Promise<[DG.Column, DG.Column]> {
+  const pi = DG.TaskBarProgressIndicator.create('PolyTool converting...');
+  try {
+    const getUnusedName = (df: DG.DataFrame | undefined, colName: string): string => {
+      if (!df) return colName;
+      return df.columns.getUnusedName(colName);
+    };
+    await getHelmHelper(); // initializes JSDraw and org
+
+    const table = seqCol.dataFrame;
+    const rules = await getRules(ruleFiles);
+    const resList = doPolyToolConvert(seqCol.toList(), rules);
+
+    const resHelmColName = getUnusedName(table, `transformed(${seqCol.name})`);
+    const resHelmCol = DG.Column.fromType(DG.COLUMN_TYPE.STRING, resHelmColName, resList.length)
+      .init((rowIdx: number) => { return resList[rowIdx];});
+    resHelmCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    resHelmCol.meta.units = NOTATION.HELM;
+    resHelmCol.setTag(DG.TAGS.CELL_RENDERER, 'helm');
+    if (generateHelm && table) table.columns.add(resHelmCol, true);
+
+    const seqHelper: ISeqHelper = await getSeqHelper();
+    const toAtomicLevelRes = await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, /* highlight */ generateHelm);
+    const resMolCol = toAtomicLevelRes.molCol;
+    resMolCol.name = getUnusedName(table, `molfile(${seqCol.name})`);
+    resMolCol.semType = DG.SEMTYPE.MOLECULE;
+    if (table) {
+      table.columns.add(resMolCol, true);
+      await grok.data.detectSemanticTypes(table);
+    }
+    return [resHelmCol, resMolCol];
+  } finally {
+    pi.close();
+  }
 }