@datagrok/sequence-translator 1.2.7 → 1.3.0

package/src/demo/demo-st-ui.ts

@@ -3,43 +3,22 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {delay} from '@datagrok-libraries/utils/src/test';
-import {getJsonData} from '../model/data-loading-utils/json-loader';
+import {loadJsonData} from '../apps/common/model/data-loader/json-loader';
 import {_package, oligoTranslatorApp, oligoPatternApp, oligoStructureApp} from '../package';
-import {tryCatch} from '../model/helpers';
+import {tryCatch} from '../apps/common/model/helpers';
 
 export async function demoOligoTranslatorUI() {
-  await tryCatch(async () => oligoTranslatorApp());
+  await tryCatch(async () => {
+    const view = await oligoTranslatorApp();
+    grok.shell.addView(view);
+  });
 }
 
 export async function demoOligoPatternUI() {
   await tryCatch(async () => {
-    async function emulateUserInput(value: string, idx: number, idxUpdate: (idx: number) => number): Promise<void> {
-      await delay(3000);
-
-      // warning: this redefinition is necessary because
-      // the ids of the elements can dynamically change
-      const choiceInputs: NodeListOf<HTMLSelectElement> = document.querySelectorAll('.st-pattern-choice-input > select');
-      len = choiceInputs.length;
-      const selectElement = choiceInputs[idxUpdate(idx)];
-      selectElement.value = value;
-      const event = new Event('input');
-      selectElement.dispatchEvent(event);
-    }
-
-    await oligoPatternApp();
-
-    let len: number;
-
-    const ssNewValues = ['DNA', 'invAb', 'Z-New'];
-    ssNewValues.forEach(async (value, idx) => {
-      emulateUserInput(value, idx, (i) => 2 * i);
-    });
-
-    const asNewValues = ['2\'-O-Methyl', '2\'-Fluoro', '2\'-O-MOE'];
-    asNewValues.forEach(async (value, idx) => {
-      emulateUserInput(value, idx, (i) => (len - 2 - 2 * i));
-    });
-  })
+    const view = await oligoPatternApp();
+    grok.shell.addView(view);
+  });
 }
 
 export async function demoOligoStructureUI() {
@@ -52,10 +31,11 @@ export async function demoOligoStructureUI() {
       const event = new Event('input');
       textarea.dispatchEvent(event);
     }
-    await oligoStructureApp();
+    const view = await oligoStructureApp();
+    grok.shell.addView(view);
     const inputSequences = ['Afcgacsu', 'Afcgacsu', 'Afcgacsu'];
     inputSequences.forEach(async (sequence, idx) => {
       await setInputValue(idx, sequence);
-    })
+    });
   });
 }

package/src/package.ts

@@ -1,94 +1,76 @@
+import DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-
-import {AppUIFactory, CombinedAppUI} from './view/app-ui';
-import {tryCatch} from './model/helpers';
-import {LIB_PATH, DEFAULT_LIB_FILENAME} from './model/data-loading-utils/const';
-import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
-import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
-import {getJsonData} from './model/data-loading-utils/json-loader';
-import {SequenceToMolfileConverter} from './model/structure-app/sequence-to-molfile';
-import {linkStrandsV3000} from './model/structure-app/mol-transformations';
-import {MonomerLibWrapper} from './model/monomer-lib/lib-wrapper';
-import {FormatDetector} from './model/parsing-validation/format-detector';
-import {SequenceValidator} from './model/parsing-validation/sequence-validator';
-import {demoOligoTranslatorUI, demoOligoPatternUI, demoOligoStructureUI} from './demo/demo-st-ui';
-import {FormatConverter} from './model/translator-app/format-converter';
-import {APP} from './view/const/ui';
-import {getExternalAppViewFactories} from './plugins/mermade';
-
-class StPackage extends DG.Package {
-  private _monomerLib?: IMonomerLib;
-
-  get monomerLib(): IMonomerLib {
-    if (!this._monomerLib)
-      throw new Error ('Monomer lib not loaded')
-    return this._monomerLib!;
-  }
-
-  public async initMonomerLib(): Promise<void> {
-    if (this._monomerLib !== undefined)
-      return;
 
-    const pi: DG.TaskBarProgressIndicator = DG.TaskBarProgressIndicator.create(
-      `Initializing ${APP.COMBINED} monomer library ...`);
-    await tryCatch(async () => {
-      const libHelper: IMonomerLibHelper = await getMonomerLibHelper();
-      this._monomerLib = await libHelper.readLibrary(LIB_PATH, DEFAULT_LIB_FILENAME);
-    }, () => pi.close());
-  }
-}
+import {loadJsonData} from './apps/common/model/data-loader/json-loader';
+import {MonomerLibWrapper} from './apps/common/model/monomer-lib/lib-wrapper';
+import {OligoToolkitPackage} from './apps/common/model/oligo-toolkit-package';
+import {FormatDetector} from './apps/common/model/parsing-validation/format-detector';
+import {SequenceValidator} from './apps/common/model/parsing-validation/sequence-validator';
+import {APP_NAME} from './apps/common/view/const';
+import {getSpecifiedAppUI} from './apps/common/view/utils';
+import {CombinedAppUI} from './apps/common/view/combined-app-ui';
+import {linkStrandsV3000} from './apps/structure/model/mol-transformations';
+import {SequenceToMolfileConverter} from './apps/structure/model/sequence-to-molfile';
+import {FormatConverter} from './apps/translator/model/format-converter';
+import {demoOligoPatternUI, demoOligoStructureUI, demoOligoTranslatorUI} from './demo/demo-st-ui';
+import {getExternalAppViewFactories} from './plugins/mermade';
 
-export const _package: StPackage = new StPackage();
+//polytool specific
+import {getPolyToolConversionDialog, getPolyToolEnumerationDialog} from './polytool/pt-dialog';
+import {_setPeptideColumn} from './polytool/utils';
+import {PolyToolCsvLibHandler} from './polytool/csv-to-json-monomer-lib-converter';
 
-async function buildLayout(appName: string): Promise<void> {
-  await initSequenceTranslatorLibData();
-  const appUI = AppUIFactory.getUI(appName);
-  await appUI.createAppLayout();
-}
 
+export const _package: OligoToolkitPackage = new OligoToolkitPackage();
 
 //name: Oligo Toolkit
 //meta.icon: img/icons/toolkit.png
 //meta.browsePath: Oligo
 //tags: app
-export async function oligoToolkitApp(): Promise<void> {
+//output: view v
+export async function oligoToolkitApp(): Promise<DG.ViewBase> {
   await initSequenceTranslatorLibData();
   const externalViewFactories = await getExternalAppViewFactories();
   if (!externalViewFactories)
     throw new Error('External app view factories not loaded');
   const appUI = new CombinedAppUI(externalViewFactories!);
-  await appUI.createAppLayout();
+  const view = await appUI.getAppView();
+  return view;
 }
 
 //name: Oligo Translator
 //meta.icon: img/icons/translator.png
 //meta.browsePath: Oligo
 //tags: app
-export async function oligoTranslatorApp(): Promise<void> {
-  await buildLayout(APP.TRANSLATOR);
+//output: view v
+export async function oligoTranslatorApp(): Promise<DG.ViewBase> {
+  const view = await getSpecifiedAppView(APP_NAME.TRANSLATOR);
+  return view;
 }
 
 //name: Oligo Pattern
 //meta.icon: img/icons/pattern.png
 //meta.browsePath: Oligo
 //tags: app
-export async function oligoPatternApp(): Promise<void> {
-  await buildLayout(APP.PATTERN);
+//output: view v
+export async function oligoPatternApp(): Promise<DG.ViewBase> {
+  const view = await getSpecifiedAppView(APP_NAME.PATTERN);
+  return view;
 }
 
 //name: Oligo Structure
 //meta.icon: img/icons/structure.png
 //meta.browsePath: Oligo
 //tags: app
-export async function oligoStructureApp(): Promise<void> {
-  await buildLayout(APP.STRUCTRE);
+//output: view v
+export async function oligoStructureApp(): Promise<DG.ViewBase> {
+  const view = await getSpecifiedAppView(APP_NAME.STRUCTURE);
+  return view;
 }
 
 //name: initSequenceTranslatorLibData
 export async function initSequenceTranslatorLibData(): Promise<void> {
-  await getJsonData();
+  await loadJsonData();
   await _package.initMonomerLib();
 }
 
@@ -152,7 +134,61 @@ export async function demoOligoStructure(): Promise<void> {
 //input: string sourceFormat
 //input: string targetFormat
 //output: string result
-export async function translateOligonucleotideSequence(sequence: string, sourceFormat: string, targetFormat: string): Promise<string> {
+export async function translateOligonucleotideSequence(
+  sequence: string, sourceFormat: string, targetFormat: string
+): Promise<string> {
   await initSequenceTranslatorLibData();
   return (new FormatConverter(sequence, sourceFormat)).convertTo(targetFormat);
 }
+
+async function getSpecifiedAppView(appName: string): Promise<DG.ViewBase> {
+  await initSequenceTranslatorLibData();
+  const appUI = getSpecifiedAppUI(appName);
+  const view = await appUI.getAppView();
+  return view;
+}
+
+//top-menu: Bio | Convert | PolyTool-Convert
+//name: polyToolConvert
+//description: Perform cyclization of polymers
+export async function polyToolConvert(): Promise<void> {
+  let dialog: DG.Dialog;
+  try {
+    dialog = await getPolyToolConversionDialog();
+    dialog.show();
+  } catch (err: any) {
+    grok.shell.warning('To run PolyTool Conversion, open a dataframe with macromolecules');
+  }
+}
+
+//top-menu: Bio | Convert | PolyTool-Enumerate
+//name: polyToolEnumerate
+//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');
+  }
+}
+
+//name: polyToolColumnChoice
+//input: dataframe df [Input data table]
+//input: column macroMolecule
+export async function polyToolColumnChoice(df: DG.DataFrame, macroMolecule: DG.Column): Promise<void> {
+  _setPeptideColumn(macroMolecule);
+  await grok.data.detectSemanticTypes(df);
+}
+
+//name: createMonomerLibraryForPolyTool
+//input: file file
+export async function createMonomerLibraryForPolyTool(file: DG.FileInfo) {
+  const fileContent = await file.readAsString();
+  const libHandler = new PolyToolCsvLibHandler(file.fileName, fileContent);
+  const libObject = await libHandler.getJson();
+  const jsonFileName = file.fileName.replace(/\.csv$/, '.json');
+  const jsonFileContent = JSON.stringify(libObject, null, 2);
+  DG.Utils.download(jsonFileName, jsonFileContent);
+}

package/src/plugins/mermade.ts

@@ -3,19 +3,19 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {ExternalPluginUI} from '../view/app-ui';
-import {ColoredTextInput} from '../view/utils/colored-input/colored-text-input';
-import {highlightInvalidSubsequence} from '../view/utils/colored-input/input-painters';
-import {codesToSymbolsDictionary} from '../model/data-loading-utils/json-loader';
+import {ExternalPluginUI} from '../apps/common/view/utils';
+import {ColoredTextInput} from '../apps/common/view/components/colored-input/colored-text-input';
+import {highlightInvalidSubsequence} from '../apps/common/view/components/colored-input/input-painters';
+import {CODES_TO_SYMBOLS_DICT} from '../apps/common/model/data-loader/json-loader';
 import {MERMADE} from './const';
 
 export async function getExternalAppViewFactories(): Promise<{[name: string]: () => DG.View} | undefined> {
   const externalPluginData = {
-  [MERMADE.FUNCTION_NAME]: {
+    [MERMADE.FUNCTION_NAME]: {
       tabName: MERMADE.TAB_NAME,
       parameters: getMerMadeParameters()
     },
-  }
+  };
 
   const result: {[tabName: string]: () => DG.View} = {};
 
@@ -30,7 +30,7 @@ export async function getExternalAppViewFactories(): Promise<{[name: string]: ()
 
       result[data.tabName] = () => pluginUI.getView();
     } catch (err) {
-      console.warn(`Plugin ${pluginName} not loaded, reason:`, err)
+      console.warn(`Plugin ${pluginName} not loaded, reason:`, err);
       continue;
     }
   }
@@ -43,6 +43,6 @@ function getMerMadeParameters(): {[name: string]: any} {
 
   return {
     coloredInput: input,
-    codes: codesToSymbolsDictionary
-  }
+    codes: CODES_TO_SYMBOLS_DICT
+  };
 }

package/src/polytool/const.ts

@@ -0,0 +1,28 @@
+import {HELM_REQUIRED_FIELD} from '@datagrok-libraries/bio/src/utils/const';
+
+export const helmFieldsToPolyToolInputFields = {
+  [HELM_REQUIRED_FIELD.SYMBOL]: 'Short Name',
+  [HELM_REQUIRED_FIELD.NAME]: 'Medium Name',
+  [HELM_REQUIRED_FIELD.SMILES]: 'SMILES',
+};
+
+export const R_GROUP_BLOCK_DUMMY = [
+  {
+    'capGroupSmiles': '[*:1][H]',
+    'alternateId': 'R1-H',
+    'capGroupName': 'H',
+    'label': 'R1'
+  },
+  {
+    'capGroupSmiles': 'O[*:2]',
+    'alternateId': 'R2-OH',
+    'capGroupName': 'OH',
+    'label': 'R2'
+  },
+  {
+    'capGroupSmiles': '[*:3][H]',
+    'alternateId': 'R3-H',
+    'capGroupName': 'H',
+    'label': 'R3'
+  }
+];

package/src/polytool/csv-to-json-monomer-lib-converter.ts

@@ -0,0 +1,40 @@
+import * as DG from 'datagrok-api/dg';
+
+import {PolyToolMonomerLibHandler} from './monomer-lib-handler';
+
+/** Handler of custom monomer libs for PolyTool  */
+export class PolyToolCsvLibHandler {
+  constructor(private fileName: string, private fileContent: string) {
+    this.validateFileType();
+    const df = DG.DataFrame.fromCsv(this.fileContent);
+    const json = this.toJson(df);
+    this.polyToolMonomerLib = new PolyToolMonomerLibHandler(json);
+    this.validateContent();
+  }
+
+  private polyToolMonomerLib: PolyToolMonomerLibHandler;
+
+  async getJson(): Promise<any> {
+    const rawLibData = this.polyToolMonomerLib.getJsonMonomerLib();
+    return rawLibData;
+  }
+
+  private toJson(df: DG.DataFrame): any[] {
+    return Array.from({length: df.rowCount}, (_, idx) =>
+      df.columns.names().reduce((entry: { [key: string]: any }, colName) => {
+        entry[colName] = df.get(colName, idx);
+        return entry;
+      }, {})
+    );
+  }
+
+  private validateFileType(): void {
+    if (!this.fileName.endsWith('.csv'))
+      throw new Error(`File ${this.fileName} is not an CSV file`);
+  }
+
+  private validateContent(): void {
+    if (!this.polyToolMonomerLib.isValid())
+      throw new Error('Invalid format of CSV monomer lib');
+  }
+}

package/src/polytool/cyclized.ts

@@ -0,0 +1,56 @@
+import {GAP_SYMBOL, INotationProvider, ISeqSplitted, SeqSplittedBase, SplitterFunc}
+  from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {getSplitterWithSeparator, StringListSeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
+import {GapOriginals} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+export class CyclizedNotationProvider implements INotationProvider {
+  private readonly separatorSplitter: SplitterFunc;
+  public readonly splitter: SplitterFunc;
+
+  constructor(
+    public readonly separator: string
+  ) {
+    this.separatorSplitter = getSplitterWithSeparator(this.separator);
+    this.splitter = this._splitter.bind(this);
+  }
+
+  private _splitter(seq: string): ISeqSplitted {
+    const baseSS: ISeqSplitted = this.separatorSplitter(seq);
+    return new CyclizedSeqSplitted(baseSS.originals, GapOriginals[NOTATION.SEPARATOR]);
+  };
+}
+
+/** Gets canonical monomers for original ones with cyclization marks */
+export class CyclizedSeqSplitted extends StringListSeqSplitted {
+  private readonly seqCList: (string | null)[];
+
+  private _canonicals: string[] | null = null;
+  override get canonicals(): SeqSplittedBase {
+    if (!this._canonicals) {
+      const len = this.length;
+      this._canonicals = new Array<string>(len);
+      for (let posIdx = 0; posIdx < len; ++posIdx)
+        this._canonicals[posIdx] = this.getCanonical(posIdx);
+    }
+    return this._canonicals;
+  }
+
+  override getCanonical(posIdx: number): string {
+    if (this.isGap(posIdx)) return GAP_SYMBOL;
+
+    let cmRes: string | null = this.seqCList[posIdx];
+    if (cmRes === null) {
+      const om = this.getOriginal(posIdx);
+      cmRes = om;
+      if (om[om.length - 1] === ')')
+        cmRes = this.seqCList[posIdx] = om.replace(/\(\d+\)$/, '');
+    }
+    return cmRes;
+  }
+
+  constructor(seqOList: SeqSplittedBase, gapOriginalMonomer: string) {
+    super(seqOList, gapOriginalMonomer);
+    this.seqCList = new Array<string | null>(this.length).fill(null);
+  }
+}

package/src/polytool/monomer-lib-handler.ts

@@ -0,0 +1,115 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {HELM_FIELDS, DUMMY_MONOMER} from '@datagrok-libraries/bio/src/utils/const';
+import {
+  helmFieldsToPolyToolInputFields, R_GROUP_BLOCK_DUMMY
+} from './const';
+import {Monomer, RGroup} from '@datagrok-libraries/bio/src/types/index';
+
+export class PolyToolMonomerLibHandler {
+  constructor(private rawLib: any[]) { }
+
+  isValid(): boolean {
+    return this.rawLib.every((entry) => {
+      return typeof entry === 'object' &&
+        Object.values(helmFieldsToPolyToolInputFields).every((field) => {
+          return field in entry &&
+            typeof entry[field] === 'string';
+        });
+    });
+  }
+
+  getJsonMonomerLib(): any {
+    const resultLib: any[] = [];
+    this.rawLib.forEach((rawMonomer) => {
+      const monomer = this.prepareMonomer(rawMonomer);
+      resultLib.push(monomer);
+    });
+    return resultLib;
+  }
+
+  private prepareMonomer(rawMonomer: any): Monomer {
+    const monomer: Monomer = {...DUMMY_MONOMER};
+
+    Object.entries(helmFieldsToPolyToolInputFields).forEach(([key, value]) => {
+      const monomerSymbol = rawMonomer[value] as string;
+      //@ts-ignore
+      monomer[key] = monomerSymbol;
+    });
+
+    let key = HELM_FIELDS.SMILES;
+    const rawSmiles = rawMonomer[helmFieldsToPolyToolInputFields[key]];
+    const smilesHandler = new SmilesHandler(rawSmiles);
+    const smiles = smilesHandler.getCappedSmiles();
+    monomer[key] = smiles;
+
+    key = HELM_FIELDS.RGROUPS;
+    monomer[key] = RGroupHandler.getRGroups(smilesHandler.getNumberOfRGroups());
+
+    key = HELM_FIELDS.MOLFILE;
+    monomer[key] = new MolBlockHandler(smilesHandler.getSmilesWithRGroups()).getMolfile();
+
+    return monomer;
+  }
+}
+
+class SmilesHandler {
+  constructor(rawSmiles: string) {
+    const regex = /\[R(\d+)\]/g;
+    let i = 0;
+    this.smilesWithRGroups = rawSmiles.replace(regex, (_, capturedDigit) => { ++i; return `[${capturedDigit}*]`; });
+    this.numberOfRGroups = i;
+  }
+
+  private numberOfRGroups: number;
+  private smilesWithRGroups: string;
+
+  getSmilesWithRGroups(): string {
+    return this.smilesWithRGroups;
+  }
+
+  getCappedSmiles(): string {
+    const smiles = this.capRGroups();
+    return smiles;
+  }
+
+  getNumberOfRGroups(): number {
+    return this.numberOfRGroups;
+  }
+
+  private capRGroups(): string {
+    let result = this.smilesWithRGroups.replace('[1*]', '[H:1]');
+    result = result.replace('[2*]', '[OH:2]');
+    return result.replace('[3*]', '[H:3]');
+  }
+}
+
+class RGroupHandler {
+  private constructor() {};
+
+  static getRGroups(numberOfRGroups: number): RGroup[] {
+    return R_GROUP_BLOCK_DUMMY.slice(0, numberOfRGroups);
+  }
+}
+
+class MolBlockHandler {
+  constructor(private smilesWithRGroups: string) { }
+
+  getMolfile(): string {
+    let molfile = DG.chem.convert(this.smilesWithRGroups, DG.chem.Notation.Smiles, DG.chem.Notation.MolBlock);
+    molfile = this.restoreRGPLine(molfile);
+    molfile = this.fixRGroupSymbols(molfile);
+    return molfile;
+  }
+
+  private restoreRGPLine(rawMolfile: string): string {
+    return rawMolfile.replace('M  ISO', 'M  RGP');
+  }
+
+  private fixRGroupSymbols(molfile: string): string {
+    return molfile.replace(/\bR\b/g, 'R#');
+  }
+}