@datagrok/bio 2.11.34 → 2.11.36

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

@@ -5,165 +5,245 @@ 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 {addCommonTags} from './utils';
-import {HELM_WRAPPER, ALL_MONOMERS, CYCLIZATION_TYPE} from './const';
-import {MetaData, ConnectionData} from './types';
+import {HELM_WRAPPER} from './const';
 import {getMolColumnFromHelm} from '../helm-to-molfile';
+import {ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
-abstract class TransformationBase {
-  constructor(helmColumn: DG.Column<string>, meta: MetaData) {
-    this.helmColumn = helmColumn;
-    this.leftTerminal = meta.leftTerminal;
-    this.rightTerminal = meta.rightTerminal;
-  }
-
-  protected helmColumn: DG.Column<string>;
-  protected leftTerminal?: string;
-  protected rightTerminal?: string;
+const RULE_PATH = 'System:AppData/Bio/polytool-rules/';
 
-  protected abstract hasTerminals(helm: string): boolean;
-  protected abstract getTransformedHelm(helm: string): string;
-  protected abstract getLinkedPositions(helm: string): [number, number];
-
-  transform(): string[] {
-    const resultList = this.helmColumn.toList().map((helm: string) => {
-      if (this.hasTerminals(helm))
-        return this.getTransformedHelm(helm);
-      return helm;
-    });
-    return resultList;
-  }
+type ConnectionData = {
+  allPos1: number[],
+  allPos2: number[],
+  allAttaches1: number[],
+  allAttaches2: number[],
 }
 
-class TransformationNCys extends TransformationBase {
-  constructor(helmColumn: DG.Column<string>, meta: MetaData) {
-    super(helmColumn, meta);
-  }
-
-  protected hasTerminals(helm: string): boolean {
-    // if (! helm.includes(this.rightTerminal + HELM_WRAPPER.RIGHT))
-    //   return false;
-    // if (this.leftTerminal === ALL_MONOMERS)
-    //   return true;
-    // return helm.includes(HELM_WRAPPER.LEFT + this.leftTerminal);
-    const positions = this.getLinkedPositions(helm);
-    return positions.every((el) => el > 0);
-  }
-
-  protected getLinkedPositions(helm: string): [number, number] {
-    const seq = helm.replace(HELM_WRAPPER.LEFT, '').replace(HELM_WRAPPER.RIGHT, '');
-    const monomers = seq.split('.');
-    const start = 0;
-    const end = monomers.findIndex((el, idx) => el === this.rightTerminal && idx > start);
-    return [start + 1, end + 1];
-  }
-
-  protected getTransformedHelm(helm: string): string {
-    const positions = this.getLinkedPositions(helm);
-    const source = {monomerPosition: positions[0], attachmentPoint: 1};
-    const target = {monomerPosition: positions[1], attachmentPoint: 3};
-    return getHelmCycle(helm, source, target);
-  }
+type Rule = {
+  code: number,
+  firstMonomer: string,
+  secondMonomer: string,
+  firstModification: string,
+  secondModification: string,
+  firstR: number,
+  secondR: number
 }
 
-class TransformationNO extends TransformationBase {
-  constructor(helmColumn: DG.Column<string>, meta: MetaData) {
-    super(helmColumn, meta);
-  }
-
-  protected hasTerminals(helm: string): boolean {
-    if (this.leftTerminal === ALL_MONOMERS || this.rightTerminal === ALL_MONOMERS)
-      return true;
-    return helm.includes(HELM_WRAPPER.LEFT + this.leftTerminal) &&
-      helm.includes(this.rightTerminal + HELM_WRAPPER.RIGHT);
-  }
-
-  protected getLinkedPositions(helm: string): [number, number] {
-    return [1, getNumberOfMonomers(helm)];
-  }
-
-  protected getTransformedHelm(helm: string): string {
-    const positions = this.getLinkedPositions(helm);
-    const source = {monomerPosition: positions[0], attachmentPoint: 1};
-    const target = {monomerPosition: positions[1], attachmentPoint: 2};
-    return getHelmCycle(helm, source, target);
-  }
+function addCommonTags(col: DG.Column):void {
+  col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
+  col.setTag('aligned', ALIGNMENT.SEQ);
+  col.setTag('alphabet', ALPHABET.PT);
 }
 
-class TransformationR3 extends TransformationBase {
-  constructor(helmColumn: DG.Column<string>, meta: MetaData) {
-    super(helmColumn, meta);
+class TransformationCommon {
+  helmColumn: DG.Column;
+
+  constructor(helmColumn: DG.Column<string>) {
+    this.helmColumn = helmColumn;
   }
 
   protected hasTerminals(helm: string): boolean {
-    if (this.leftTerminal === ALL_MONOMERS || this.rightTerminal === ALL_MONOMERS)
-      return true;
-    const positions = this.getLinkedPositions(helm);
-    return positions.every((el) => el > 0);
+    let isLinkable = false;
+    if (helm.includes('(1)'))
+      isLinkable = true;
+    if (helm.includes('(2)'))
+      isLinkable = true;
+
+    return isLinkable;
   }
 
-  protected getLinkedPositions(helm: string): [number, number] {
+  protected getLinkedPositions(helm: string, rules: Rule[]): [number, number][] {
     const seq = helm.replace(HELM_WRAPPER.LEFT, '').replace(HELM_WRAPPER.RIGHT, '');
-    const monomers = seq.split('.');
-    const start = monomers.findIndex((el) => el === this.leftTerminal);
-    const end = monomers.findIndex((el, idx) => el === this.rightTerminal && idx > start);
-    return [start + 1, end + 1];
-  }
+    const monomers = seq.split('.').map((m) => { return m.replace('[', '').replace(']', ''); });
+    const result:[number, number][] = new Array<[number, number]>(rules.length);
+
+    for (let i = 0; i < rules.length; i++) {
+      let firstFound = false;
+      let secondFound = false;
+      let firstIsFirst = false;
+      let firstEntryIndex = -1;
+      let secondEntryIndex = -1;
+      const add = `(${rules[i].code})`;
+      for (let j = 0; j < monomers.length; j++) {
+        if (monomers[j].includes(add)) {
+          if (firstFound) {
+            if (firstIsFirst && monomers[j] == rules[i].secondMonomer + add) {
+              secondFound = true;
+              secondEntryIndex = j;
+              break;
+            } else if (!firstIsFirst && monomers[j] == rules[i].firstMonomer + add) {
+              secondFound = true;
+              secondEntryIndex = j;
+              break;
+            } else {
+              continue;
+            }
+            //result[i][1] = j;
+            // secondFound = true;
+            // break;
+          } else {
+            if (monomers[j] == rules[i].firstMonomer + add) {
+              firstFound = true;
+              firstIsFirst = true;
+              firstEntryIndex = j;
+            } else if (monomers[j] == rules[i].secondMonomer + add) {
+              firstFound = true;
+              firstIsFirst = false;
+              firstEntryIndex = j;
+            } else {
+              continue;
+            }
+            //result[i] = [j, 0];
+          }
+        }
+      }
+
+      if (!(firstFound && secondFound))
+        result[i] = [-1, -1];
+      else if (firstIsFirst)
+        result[i] = [firstEntryIndex, secondEntryIndex];
+      else
+        result[i] = [secondEntryIndex, firstEntryIndex];
+    }
+
+
+    return result;
+  }
+
+  protected getRules(rulesTable: DG.DataFrame): Rule[] {
+    const ruleCount = rulesTable.rowCount;
+    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),
+      };
+    }
+
+    return rules;
+  }
+
+  protected getTransformedHelm(helm: string, rules: Rule[]): string {
+    const ruleCount = rules.length;
+    const positions = this.getLinkedPositions(helm, rules);
+
+    const allPos1: number [] = [];
+    const allPos2: number [] = [];
+    const allAttaches1: number [] = [];
+    const allAttaches2: number [] = [];
+
+    for (let i = 0; i < ruleCount; i++) {
+      if (positions[i][0] == -1)
+        continue;
+
+      //helm = helm.replaceAll(`(${i + 1})`, '');
+      const seq = helm.replace(HELM_WRAPPER.LEFT, '').replace(HELM_WRAPPER.RIGHT, '');
+      const monomers = seq.split('.');
+      const firstMonomer = monomers[positions[i][0]].replace('[', '').replace(']', '');
+      const secondMonomer = monomers[positions[i][1]].replace('[', '').replace(']', '');
+
+      monomers[positions[i][0]] = monomers[positions[i][0]].replace(firstMonomer, rules[i].firstModification);
+      monomers[positions[i][1]] = monomers[positions[i][1]].replace(secondMonomer, rules[i].secondModification);
+
+      allPos1.push(positions[i][0] + 1);
+      allPos2.push(positions[i][1] + 1);
+      allAttaches1.push(rules[i].firstR);
+      allAttaches2.push(rules[i].secondR);
+
+      helm = HELM_WRAPPER.LEFT;
+      for (let i = 0; i < monomers.length; i ++) {
+        if (i != monomers.length - 1)
+          helm = helm + monomers[i] + '.';
+        else
+          helm = helm + monomers[i];
+      }
+      helm = helm + HELM_WRAPPER.RIGHT;
+    }
+
+
+    const cycledHelm = getHelmCycle(helm, {allPos1, allPos2, allAttaches1, allAttaches2});
+
+    return cycledHelm;
+  }
+
+  transform(rulesTable: DG.DataFrame): string[] {
+    const rules = this.getRules(rulesTable);
+    const resultList = this.helmColumn.toList().map((helm: string) => {
+      if (this.hasTerminals(helm))
+        return this.getTransformedHelm(helm, rules);
 
-  protected getTransformedHelm(helm: string): string {
-    const positions = this.getLinkedPositions(helm);
-    const source = {monomerPosition: positions[0], attachmentPoint: 3};
-    const target = {monomerPosition: positions[1], attachmentPoint: 3};
-    return getHelmCycle(helm, source, target);
+      console.log(helm);
+      return helm;
+    });
+    return resultList;
   }
 }
 
 class PolymerTransformation {
   private constructor() {}
 
-  static getInstance(molColumn: DG.Column<string>, meta: MetaData): TransformationBase {
-    const cyclizationType = meta.cyclizationType;
-    return (cyclizationType === CYCLIZATION_TYPE.R3) ? new TransformationR3(molColumn, meta) :
-      (cyclizationType === CYCLIZATION_TYPE.NCys) ? new TransformationNCys(molColumn, meta) :
-        new TransformationNO(molColumn, meta);
+  static getInstance(molColumn: DG.Column<string>) {
+    return new TransformationCommon(molColumn);
   }
 }
 
-function getNumberOfMonomers(helm: string): number {
-  const seq = helm.replace(HELM_WRAPPER.LEFT, '').replace(HELM_WRAPPER.RIGHT, '');
-  return seq.split('.').length;
-}
-
-function getHelmCycle(helm: string, source: ConnectionData, target: ConnectionData): string {
-  return helm.replace(HELM_WRAPPER.RIGHT,
-    `}$PEPTIDE1,PEPTIDE1,${
-      source.monomerPosition
-    }:R${
-      source.attachmentPoint
-    }-${
-      target.monomerPosition
-    }:R${
-      target.attachmentPoint
-    }${'$'.repeat(6)}`
-  );
+function getHelmCycle(helm: string, source: ConnectionData): string {
+  let cycled = helm.replace(HELM_WRAPPER.RIGHT, '}$');
+
+  for (let i = 0; i < source.allPos1.length; i++) {
+    if (i == 0)
+      cycled += 'PEPTIDE1,PEPTIDE1,';
+    else
+      cycled += '|PEPTIDE1,PEPTIDE1,';
+    cycled += `${source.allPos1[i]}:R${source.allAttaches1[i]}-${source.allPos2[i]}:R${source.allAttaches2[i]}`;
+  }
+
+  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>, meta: MetaData, addHelm: boolean
+  molColumn: DG.Column<string>, addHelm: boolean
 ): Promise<void> {
   const df = molColumn.dataFrame;
   const uh = UnitsHandler.getOrCreate(molColumn);
   const sourceHelmCol = uh.convert(NOTATION.HELM);
-  const pt = PolymerTransformation.getInstance(sourceHelmCol, meta);
-  const targetList = pt.transform();
-  const helmColName = df.columns.getUnusedName(`${meta.transformationType}(` + molColumn.name + ')');
+  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 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);
-  molCol.name = df.columns.getUnusedName(`${meta.transformationType}_molfile(` + molColumn.name + ')');
+  molCol.name = df.columns.getUnusedName('molfile(' + molColumn.name + ')');
 
   if (addHelm) {
     targetHelmCol.setTag('cell.renderer', 'helm');

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

@@ -8,90 +8,15 @@ 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';
+//import {MetaData} from './types';
 
-export function getPolyToolDialog(): DG.Dialog {
-  function getMonomerList(cyclizationType: CYCLIZATION_TYPE): string[] {
-    if (cyclizationType === cyclizationTypes[0]) {
-      return [ALL_MONOMERS].concat(
-        monomerLib.getMonomerSymbolsByType(HELM_POLYMER_TYPE.PEPTIDE)
-      );
-    }
-    if (cyclizationType === cyclizationTypes[1]) {
-      return [ALL_MONOMERS].concat(
-        monomerLib.getMonomerSymbolsByRGroup(3, HELM_POLYMER_TYPE.PEPTIDE)
-      );
-    }
-    return ['C'];
-  }
-
-  function updateMonomerList(): void {
-    if (cyclizationTypeChoice.value === CYCLIZATION_TYPE.NCys) {
-      monomerList1 = getMonomerList(CYCLIZATION_TYPE.NO);
-      monomerList2 = getMonomerList(CYCLIZATION_TYPE.NCys);
-    } else {
-      monomerList1 = getMonomerList(cyclizationTypeChoice.value as CYCLIZATION_TYPE);
-      monomerList2 = [...monomerList1];
-    }
-
-    leftTerminalChoice = ui.choiceInput(
-      'R1:', monomerList1[0], monomerList1, () => { onRGroupValueChange.next(); }
-    );
-    rightTerminalChoice = ui.choiceInput('R2:', monomerList2[0], monomerList2, () => { onRGroupValueChange.next(); });
-    onRGroupValueChange.next();
-    ui.empty(terminalControls);
-    [leftTerminalChoice, rightTerminalChoice].forEach((el) => { terminalControls.appendChild(el.root); });
-  }
-
-  function updateMeta() {
-    meta.cyclizationType = cyclizationTypeChoice.value!;
-    meta.leftTerminal = leftTerminalChoice.value!;
-    meta.rightTerminal = rightTerminalChoice.value!;
-    meta.transformationType = transformationChoice.value!;
-  }
-
-
-  const onCyclizationChoice = new rxjs.Subject<string>();
-  const onRGroupValueChange = new rxjs.Subject<string>();
-  onCyclizationChoice.subscribe(() => {
-    meta.cyclizationType = cyclizationTypeChoice.value!;
-    updateMonomerList();
-  });
-  onRGroupValueChange.subscribe(() => {
-    meta.rightTerminal = rightTerminalChoice.value!;
-    meta.leftTerminal = leftTerminalChoice.value!;
-  });
-
-  const meta = {} as MetaData;
-  const transformations = [TRANSFORMATION_TYPE.CYCLIZATION];
-  const transformationChoice = ui.choiceInput(
-    'Modification', transformations[0], transformations, () => meta.transformationType = transformationChoice.value!
-  );
-
-  const cyclizationTypes = [CYCLIZATION_TYPE.NO, CYCLIZATION_TYPE.R3, CYCLIZATION_TYPE.NCys];
-  const cyclizationTypeChoice = ui.choiceInput(
-    'Type', cyclizationTypes[2], cyclizationTypes, () => { onCyclizationChoice.next(); }
-  );
-
-  const monomerLib = MonomerLibManager.instance.getBioLib();
-  let monomerList1: string[] = [];
-  let monomerList2: string[] = [];
-  let leftTerminalChoice = ui.choiceInput(
-    'R1:', monomerList1[0], monomerList1, () => {
-      meta.leftTerminal = leftTerminalChoice.value!;
-    }
-  );
-  let rightTerminalChoice = ui.choiceInput('R2:', monomerList2[0], monomerList2, () => {
-    meta.rightTerminal = rightTerminalChoice.value!;
-  });
-  const terminalControls = ui.divV([leftTerminalChoice.root, rightTerminalChoice.root]);
-  updateMonomerList();
-
-  updateMeta();
+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 maceomolecule columns open');
+    throw new Error('No dataframe with macromolecule columns open');
 
   const targetColumnInput = ui.columnInput(
     'Column', grok.shell.t, targetColumns[0], null,
@@ -101,12 +26,24 @@ export function getPolyToolDialog(): DG.Dialog {
   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());
+      },
+    });
+  });
+
   const div = ui.div([
     targetColumnInput,
-    transformationChoice,
-    cyclizationTypeChoice,
-    terminalControls,
     generateHelmChoiceInput,
+    ruleFileInput
   ]);
 
   const dialog = ui.dialog('Poly Tool')
@@ -117,7 +54,7 @@ export function getPolyToolDialog(): DG.Dialog {
         grok.shell.warning('No marcomolecule column chosen!');
         return;
       }
-      addTransformedColumn(molCol!, meta, generateHelmChoiceInput.value!);
+      addTransformedColumn(molCol!, generateHelmChoiceInput.value!);
     }
     );
 

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

@@ -3,13 +3,7 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {NOTATION, ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
-
-export function addCommonTags(col: DG.Column):void {
-  col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
-  col.setTag('aligned', ALIGNMENT.SEQ);
-  col.setTag('alphabet', ALPHABET.PT);
-}
+import {ALPHABET, ALIGNMENT, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 export function _setPeptideColumn(col: DG.Column): void {
   addCommonTags(col);
@@ -18,3 +12,9 @@ export function _setPeptideColumn(col: DG.Column): void {
   // col.setTag('cell.renderer', 'sequence');
 }
 
+function addCommonTags(col: DG.Column<any>) {
+  col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
+  col.setTag('aligned', ALIGNMENT.SEQ);
+  col.setTag('alphabet', ALPHABET.PT);
+}
+

package/src/widgets/bio-substructure-filter-helm.ts

@@ -87,7 +87,7 @@ export class HelmBioFilter extends BioFilterBase<BioFilterProps> /* implements I
         //   webEditor = undefined;
         // });
       }));
-      this.viewSubs.push(ui.onSizeChanged(this._filterPanel).subscribe((_) => {
+      this.viewSubs.push(ui.onSizeChanged(this._filterPanel).subscribe((_: any) => {
         try {
           if (!!webEditorApp) {
             const helmString = webEditorApp.canvas.getHelm(true)
@@ -110,7 +110,7 @@ export class HelmBioFilter extends BioFilterBase<BioFilterProps> /* implements I
 
   applyProps() {
     if (!this.helmEditor) return; // helmEditor is not created, the filter is not in dom yet
-    this.helmEditor.editor.setHelm(this.props.substructure);
+    this.updateFilterPanel(this.props.substructure);
   }
 
   get filterPanel() {

package/webpack.config.js

@@ -3,6 +3,9 @@ const FuncGeneratorPlugin = require('datagrok-tools/plugins/func-gen-plugin');
 const packageName = path.parse(require('./package.json').name).name.toLowerCase().replace(/-/g, '');
 
 module.exports = {
+  cache: {
+    type: 'filesystem',
+  },
   mode: 'development',
   entry: {
     package: ['./src/package.ts'],

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

@@ -1,20 +0,0 @@
-import {TRANSFORMATION_TYPE, CYCLIZATION_TYPE} from './const';
-
-export type MetaData = {
-  leftTerminal: string,
-  rightTerminal: string,
-  transformationType: TRANSFORMATION_TYPE,
-  cyclizationType: CYCLIZATION_TYPE,
-}
-
-export type ConnectionData = {
-  monomerPosition: number,
-  attachmentPoint: number,
-}
-
-export type PolyToolLib = {
-  'Short Name': string,
-  'Medium Name': string,
-  'SMILES': string,
-  'Synonyms': string
-}