@datagrok/bio 2.11.39 → 2.11.41

package/files/polytool-rules/rules_template.csv

@@ -0,0 +1 @@
+code,monomer1,monomer2,modification1,modification2,R1,R2

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.11.39",
+  "version": "2.11.41",
   "description": "Bioinformatics support (import/export of sequences, conversion, visualization, analysis). [See more](https://github.com/datagrok-ai/public/blob/master/packages/Bio/README.md) for details.",
   "repository": {
     "type": "git",

package/src/package.ts

@@ -59,7 +59,7 @@ import {BioPackage, BioPackageProperties} from './package-types';
 import {getCompositionAnalysisWidget} from './widgets/composition-analysis-widget';
 import {MacromoleculeColumnWidget} from './utils/macromolecule-column-widget';
 import {addCopyMenuUI} from './utils/context-menu';
-import {getPolyToolDialog} from './utils/poly-tool/ui';
+import {PolyTool} from './utils/poly-tool/ui';
 import {PolyToolCsvLibHandler} from './utils/poly-tool/csv-to-json-monomer-lib-converter';
 import {_setPeptideColumn} from './utils/poly-tool/utils';
 import {getRegionDo} from './utils/get-region';
@@ -689,10 +689,11 @@ export function convertDialog() {
 //top-menu: Bio | Convert | PolyTool
 //name: polyTool
 //description: Perform cyclization of polymers
-export function polyTool(): void {
+export async function polyTool(): Promise<void> {
+  const polytool = new PolyTool();
   let dialog: DG.Dialog;
   try {
-    dialog = getPolyToolDialog();
+    dialog = await polytool.getPolyToolDialog();
     dialog.show();
   } catch (err: any) {
     grok.shell.warning('To run PolyTool, open a dataframe with macromolecules');

package/src/utils/helm-to-molfile.ts

@@ -1,11 +1,11 @@
 /* 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 * as OCL from 'openchemlib/full';
 
 import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
 import {MolfileHandlerBase} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler-base';
-import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {RDModule, RDMol} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {HELM_POLYMER_TYPE, HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 
@@ -51,10 +51,10 @@ export async function helm2mol(df: DG.DataFrame, helmCol: DG.Column<string>): Pr
 
 /** Translate HELM column into molfile column and append to the dataframe */
 export async function getMolColumnFromHelm(
-  df: DG.DataFrame, helmCol: DG.Column<string>
+  df: DG.DataFrame, helmCol: DG.Column<string>, chiralityEngine?: boolean
 ): Promise<DG.Column<string>> {
   const converter = new HelmToMolfileConverter(helmCol, df);
-  const molCol = await converter.convertToRdKitBeautifiedMolfileColumn();
+  const molCol = await converter.convertToRdKitBeautifiedMolfileColumn(chiralityEngine);
   molCol.semType = DG.SEMTYPE.MOLECULE;
   return molCol;
 }
@@ -89,7 +89,28 @@ export class HelmToMolfileConverter {
     return smiles;
   }
 
-  async convertToRdKitBeautifiedMolfileColumn(): Promise<DG.Column<string>> {
+  async getMolV3000ViaOCL(beautifiedMols: (RDMol | null)[], columnName: string) {
+    const beautifiedMolV2000 =  beautifiedMols.map((mol) => {
+      if (mol === null)
+        return '';
+      const molBlock = mol.get_molblock();
+      mol!.delete();
+      return molBlock;
+    });
+    const molv3000Arr = new Array<string>(beautifiedMolV2000.length);
+    const chiralityPb = DG.TaskBarProgressIndicator.create(`Handling chirality...`);
+    for (let i = 0; i < beautifiedMolV2000.length; i++) {
+      const oclMolecule = OCL.Molecule.fromMolfile(beautifiedMolV2000[i]);
+      const molV3000 = oclMolecule.toMolfileV3();
+      molv3000Arr[i] = molV3000.replace('STERAC1', 'STEABS');
+      const progress = i/beautifiedMolV2000.length*100;
+      chiralityPb.update(progress, `${progress?.toFixed(2)}% of molecules completed`);
+    }
+    chiralityPb.close();
+    return DG.Column.fromStrings(columnName, molv3000Arr); 
+  }
+
+  async convertToRdKitBeautifiedMolfileColumn(chiralityEngine?: boolean): Promise<DG.Column<string>> {
     const smiles = await this.getSmilesList();
     const rdKitModule: RDModule = await grok.functions.call('Chem:getRdKitModule');
     const beautifiedMols = smiles.map((item) =>{
@@ -103,13 +124,16 @@ export class HelmToMolfileConverter {
       return mol;
     });
     const columnName = this.df.columns.getUnusedName(`molfile(${this.helmColumn.name})`);
+
+    if (chiralityEngine)
+      return await this.getMolV3000ViaOCL(beautifiedMols, columnName);
     return DG.Column.fromStrings(columnName, beautifiedMols.map((mol) => {
       if (mol === null)
         return '';
       const molBlock = mol.get_v3Kmolblock();
       mol!.delete();
       return molBlock;
-    }));
+    })); 
   }
 
   async convertToMolfileV2KColumn(): Promise<DG.Column<string>> {

package/src/utils/poly-tool/transformation.ts

@@ -4,12 +4,14 @@ import * as DG from 'datagrok-api/dg';
 
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
-import {_package} from '../../package';
+import {ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
 import {HELM_WRAPPER} from './const';
 import {getMolColumnFromHelm} from '../helm-to-molfile';
-import {ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
-const RULE_PATH = 'System:AppData/Bio/polytool-rules/';
+export const RULES_PATH = 'System:AppData/Bio/polytool-rules/';
+export const RULES_STORAGE_NAME = 'Polytool';
+
 
 type ConnectionData = {
   allPos1: number[],
@@ -28,7 +30,7 @@ type Rule = {
   secondR: number
 }
 
-function addCommonTags(col: DG.Column):void {
+function addCommonTags(col: DG.Column): void {
   col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
   col.setTag('aligned', ALIGNMENT.SEQ);
   col.setTag('alphabet', ALPHABET.PT);
@@ -54,7 +56,7 @@ class TransformationCommon {
   protected getLinkedPositions(helm: string, rules: Rule[]): [number, number][] {
     const seq = helm.replace(HELM_WRAPPER.LEFT, '').replace(HELM_WRAPPER.RIGHT, '');
     const monomers = seq.split('.').map((m) => { return m.replace('[', '').replace(']', ''); });
-    const result:[number, number][] = new Array<[number, number]>(rules.length);
+    const result: [number, number][] = new Array<[number, number]>(rules.length);
 
     for (let i = 0; i < rules.length; i++) {
       let firstFound = false;
@@ -109,27 +111,31 @@ class TransformationCommon {
     return result;
   }
 
-  protected getRules(rulesTable: DG.DataFrame): Rule[] {
-    const ruleCount = rulesTable.rowCount;
+  protected getRules(rulesTables: DG.DataFrame[]): Rule[] {
+    const ruleCount = rulesTables.map((df) => df.rowCount).reduce((a, b) => a + b);
     const rules: Rule[] = new Array<Rule>(ruleCount);
-    const codeCol = rulesTable.columns.byName('code');
-    const monomer1Col = rulesTable.columns.byName('monomer1');
-    const monomer2Col = rulesTable.columns.byName('monomer2');
-    const modification1Col = rulesTable.columns.byName('modification1');
-    const modification2Col = rulesTable.columns.byName('modification2');
-    const r1Col = rulesTable.columns.byName('R1');
-    const r2Col = rulesTable.columns.byName('R2');
 
-    for (let i = 0; i < ruleCount; i++) {
-      rules[i] = {
-        code: codeCol.get(i),
-        firstMonomer: monomer1Col.get(i),
-        secondMonomer: monomer2Col.get(i),
-        firstModification: modification1Col.get(i),
-        secondModification: modification2Col.get(i),
-        firstR: r1Col.get(i),
-        secondR: r2Col.get(i),
-      };
+    let counter = 0;
+    for (let i = 0; i < rulesTables.length; i++) {
+      const codeCol = rulesTables[i].columns.byName('code');
+      const monomer1Col = rulesTables[i].columns.byName('monomer1');
+      const monomer2Col = rulesTables[i].columns.byName('monomer2');
+      const modification1Col = rulesTables[i].columns.byName('modification1');
+      const modification2Col = rulesTables[i].columns.byName('modification2');
+      const r1Col = rulesTables[i].columns.byName('R1');
+      const r2Col = rulesTables[i].columns.byName('R2');
+
+      for (let j = 0; j < rulesTables[i].rowCount; j++, counter++) {
+        rules[counter] = {
+          code: codeCol.get(j),
+          firstMonomer: monomer1Col.get(j),
+          secondMonomer: monomer2Col.get(j),
+          firstModification: modification1Col.get(j),
+          secondModification: modification2Col.get(j),
+          firstR: r1Col.get(j),
+          secondR: r2Col.get(j),
+        };
+      }
     }
 
     return rules;
@@ -163,7 +169,7 @@ class TransformationCommon {
       allAttaches2.push(rules[i].secondR);
 
       helm = HELM_WRAPPER.LEFT;
-      for (let i = 0; i < monomers.length; i ++) {
+      for (let i = 0; i < monomers.length; i++) {
         if (i != monomers.length - 1)
           helm = helm + monomers[i] + '.';
         else
@@ -178,8 +184,8 @@ class TransformationCommon {
     return cycledHelm;
   }
 
-  transform(rulesTable: DG.DataFrame): string[] {
-    const rules = this.getRules(rulesTable);
+  transform(rulesTables: DG.DataFrame[]): string[] {
+    const rules = this.getRules(rulesTables);
     const resultList = this.helmColumn.toList().map((helm: string) => {
       if (this.hasTerminals(helm))
         return this.getTransformedHelm(helm, rules);
@@ -212,37 +218,32 @@ function getHelmCycle(helm: string, source: ConnectionData): string {
 
   cycled += '$$$';
   return cycled;
-  // return helm.replace(HELM_WRAPPER.RIGHT,
-  //   `}$PEPTIDE1,PEPTIDE1,${
-  //     source.monomerPosition
-  //   }:R${
-  //     source.attachmentPoint
-  //   }-${
-  //     target.monomerPosition
-  //   }:R${
-  //     target.attachmentPoint
-  //   }${'$'.repeat(6)}`
-  // );
 }
 
 export async function addTransformedColumn(
-  molColumn: DG.Column<string>, addHelm: boolean
+  molColumn: DG.Column<string>, addHelm: boolean, ruleFiles: string[], chiralityEngine?: boolean
 ): Promise<void> {
   const df = molColumn.dataFrame;
   const uh = UnitsHandler.getOrCreate(molColumn);
   const sourceHelmCol = uh.convert(NOTATION.HELM);
   const pt = PolymerTransformation.getInstance(sourceHelmCol);
-  const fileSource = new DG.FileSource(RULE_PATH);
-  const rulesRaw = await fileSource.readAsText('rules.csv');
-  const rulesTable = DG.DataFrame.fromCsv(rulesRaw);
-  const targetList = pt.transform(rulesTable);
+  const fileSource = new DG.FileSource(RULES_PATH);
+
+  const rulesRawFrames: DG.DataFrame[] = new Array<DG.DataFrame>(ruleFiles.length);
+
+  for (let i = 0; i < ruleFiles.length; i++) {
+    const rulesRaw = await fileSource.readAsText(ruleFiles[i].replace(RULES_PATH, ''));
+    rulesRawFrames[i] = DG.DataFrame.fromCsv(rulesRaw);
+  }
+
+  const targetList = pt.transform(rulesRawFrames);
   const helmColName = df.columns.getUnusedName('transformed(' + molColumn.name + ')');
   const targetHelmCol = DG.Column.fromList('string', helmColName, targetList);
 
   addCommonTags(targetHelmCol);
   targetHelmCol.setTag('units', NOTATION.HELM);
 
-  const molCol = await getMolColumnFromHelm(df, targetHelmCol);
+  const molCol = await getMolColumnFromHelm(df, targetHelmCol, chiralityEngine);
   molCol.name = df.columns.getUnusedName('molfile(' + molColumn.name + ')');
 
   if (addHelm) {

package/src/utils/poly-tool/ui.ts

@@ -3,60 +3,146 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {HELM_POLYMER_TYPE} from '@datagrok-libraries/bio/src/utils/const';
-import {MonomerLibManager} from '../monomer-lib/lib-manager';
-import {ALL_MONOMERS, CYCLIZATION_TYPE, TRANSFORMATION_TYPE} from './const';
 import {addTransformedColumn} from './transformation';
-import * as rxjs from 'rxjs';
-//import {MetaData} from './types';
-
-const RULE_PATH = 'System:AppData/Bio/polytool-rules/';
-
-export function getPolyToolDialog(): DG.Dialog {
-  //const monomerLib = MonomerLibManager.instance.getBioLib();
-  const targetColumns = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
-  if (!targetColumns)
-    throw new Error('No dataframe with macromolecule columns open');
-
-  const targetColumnInput = ui.columnInput(
-    'Column', grok.shell.t, targetColumns[0], null,
-    {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE}
-  );
-
-  const generateHelmChoiceInput = ui.boolInput('Get HELM', true);
-  ui.tooltip.bind(generateHelmChoiceInput.root, 'Add HELM column');
-
-  // let rulesTable: DG.DataFrame = DG.DataFrame.create();
-
-  const ruleFileInput = ui.button('ADD RULES', () => {
-    DG.Utils.openFile({
-      accept: '.csv',
-      open: async (selectedFile) => {
-        const content = await selectedFile.text();
-        // rulesTable = DG.DataFrame.fromCsv(content);
-        await grok.dapi.files.writeAsText(RULE_PATH + `${selectedFile.name}`, content);
-        //console.log(df.toCsv());
-      },
-    });
+import {RULES_PATH, RULES_STORAGE_NAME} from './transformation';
+
+export type UserRuleSettings = {
+  included: string[],
+  notIncluded: string[],
+}
+
+async function getAllAvailableRuleFiles(): Promise<string[]> {
+  const list = await grok.dapi.files.list(RULES_PATH);
+  const paths = list.map((fileInfo) => {
+    return fileInfo.fullPath;
   });
 
-  const div = ui.div([
-    targetColumnInput,
-    generateHelmChoiceInput,
-    ruleFileInput
-  ]);
-
-  const dialog = ui.dialog('Poly Tool')
-    .add(div)
-    .onOK(async () => {
-      const molCol = targetColumnInput.value;
-      if (!molCol) {
-        grok.shell.warning('No marcomolecule column chosen!');
-        return;
-      }
-      addTransformedColumn(molCol!, generateHelmChoiceInput.value!);
+  return paths;
+}
+
+async function getUserRulesSettings(): Promise<UserRuleSettings> {
+  const resStr: string = await grok.dapi.userDataStorage.getValue(RULES_STORAGE_NAME, 'Settings', true);
+  const res = resStr ? JSON.parse(resStr) : {included: [], enotIncludedxplicit: []};
+
+  res.included = res.included instanceof Array ? res.included : [];
+  res.notIncluded = res.notIncluded instanceof Array ? res.notIncluded : [];
+
+  return res!;
+}
+
+async function setUserLibSettings(value: UserRuleSettings): Promise<void> {
+  await grok.dapi.userDataStorage.postValue(RULES_STORAGE_NAME, 'Settings', JSON.stringify(value), true);
+}
+
+export class PolyTool {
+  ruleFiles: string[];
+  userRuleSettings: UserRuleSettings;
+  ruleFilesInputs: HTMLDivElement;// DG.InputBase<boolean | null>[];
+  dialog: DG.Dialog;
+
+  constructor() {
+    this.ruleFiles = [];
+    this.userRuleSettings = {included: [], notIncluded: []};
+  }
+
+  private updateRulesSelectionStatus(ruleFileName: string, isSelected: boolean): void {
+    const isRuleFileSelected = this.userRuleSettings.included.includes(ruleFileName);
+
+    if (!isRuleFileSelected && isSelected) {
+      this.userRuleSettings.included.push(ruleFileName);
+      this.userRuleSettings.included = this.userRuleSettings.included.sort();
+
+      const index = this.userRuleSettings.notIncluded.indexOf(ruleFileName);
+      if (index > -1)
+        this.userRuleSettings.notIncluded.splice(index, 1);
+    } else {
+      const index = this.userRuleSettings.included.indexOf(ruleFileName);
+      if (index > -1)
+        this.userRuleSettings.included.splice(index, 1);
+
+      this.userRuleSettings.notIncluded.push(ruleFileName);
+      this.userRuleSettings.notIncluded = this.userRuleSettings.notIncluded.sort();
     }
+
+    setUserLibSettings(this.userRuleSettings);
+  }
+
+  private getAddButton(): HTMLButtonElement {
+    return ui.button('ADD RULES', () => {
+      DG.Utils.openFile({
+        accept: '.csv',
+        open: async (selectedFile) => {
+          const content = await selectedFile.text();
+          await grok.dapi.files.writeAsText(RULES_PATH + `${selectedFile.name}`, content);
+          this.updateRulesSelectionStatus(selectedFile.name, false);
+          const cb = ui.boolInput(
+            selectedFile.name,
+            false,
+            (isSelected: boolean) => this.updateRulesSelectionStatus(RULES_PATH + `${selectedFile.name}`, isSelected)
+          );
+          this.ruleFilesInputs.append(cb.root);
+        },
+      });
+    });
+  }
+
+  private async getRuleFilesBlock(): Promise<DG.InputBase<boolean | null>[]> {
+    this.ruleFiles = await getAllAvailableRuleFiles();
+    this.userRuleSettings = await getUserRulesSettings();
+    const cBoxes: DG.InputBase<boolean | null>[] = [];
+
+    for (let i = 0; i < this.ruleFiles.length; i++) {
+      const ruleFileName = this.ruleFiles[i];
+      const isRuleFileSelected = this.userRuleSettings.included.includes(ruleFileName);
+      const cb = ui.boolInput(
+        ruleFileName.replace(RULES_PATH, ''),
+        isRuleFileSelected,
+        (isSelected: boolean) => this.updateRulesSelectionStatus(ruleFileName, isSelected)
+      );
+
+      cBoxes.push(cb);
+    }
+    return cBoxes;
+  }
+
+  async getPolyToolDialog(): Promise<DG.Dialog> {
+    const targetColumns = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
+    if (!targetColumns)
+      throw new Error('No dataframe with macromolecule columns open');
+
+    const targetColumnInput = ui.columnInput(
+      'Column', grok.shell.t, targetColumns[0], null,
+      {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE}
     );
 
-  return dialog;
+    const generateHelmChoiceInput = ui.boolInput('Get HELM', true);
+    ui.tooltip.bind(generateHelmChoiceInput.root, 'Add HELM column');
+
+    const addButton = this.getAddButton();
+    this.ruleFilesInputs = ui.div(await this.getRuleFilesBlock());
+    //const rulesFiles = ui.div(this.ruleFilesInputs);
+    const chiralityEngineInput = ui.boolInput('Chirality engine', false);
+
+    const div = ui.div([
+      targetColumnInput,
+      generateHelmChoiceInput,
+      chiralityEngineInput,
+      'Rules used',
+      this.ruleFilesInputs,
+      addButton
+    ]);
+
+    this.dialog = ui.dialog('Poly Tool')
+      .add(div)
+      .onOK(async () => {
+        const molCol = targetColumnInput.value;
+        if (!molCol) {
+          grok.shell.warning('No marcomolecule column chosen!');
+          return;
+        }
+        addTransformedColumn(molCol!, generateHelmChoiceInput.value!, this.userRuleSettings.included, chiralityEngineInput.value!);
+      });
+
+    return this.dialog;
+  }
 }