@datagrok/bio 2.0.18 → 2.0.19

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.0.18",
+  "version": "2.0.19",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",

package/src/package.ts

@@ -31,6 +31,7 @@ import {SequenceSimilarityViewer} from './analysis/sequence-similarity-viewer';
 import {SequenceDiversityViewer} from './analysis/sequence-diversity-viewer';
 import {substructureSearchDialog} from './substructure-search/substructure-search';
 import {saveAsFastaUI} from './utils/save-as-fasta';
+import {BioSubstructureFilter} from './widgets/bio-substructure-filter';
 
 //tags: init
 export async function initBio() {
@@ -517,4 +518,14 @@ export function bioSubstructureSearch(col: DG.Column): void {
 //tags: fileExporter
 export function saveAsFasta() {
   saveAsFastaUI();
-}
+}
+//name: BioSubstructureFilter
+//description: Substructure filter for linear macromolecules
+//tags: filter
+//output: filter result
+//meta.semType: Macromolecule
+export function bioSubstructureFilter(): BioSubstructureFilter {
+  return new BioSubstructureFilter();
+}
+
+

package/src/substructure-search/substructure-search.ts

@@ -3,6 +3,9 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/units-handler';
 import * as C from '../utils/constants';
+import {getMonomericMols} from '../calculations/monomerLevelMols';
+import {BitSet} from 'datagrok-api/dg';
+import {updateDivInnerHTML} from '../utils/ui-utils';
 
 /**
  * Searches substructure in each row of Macromolecule column
@@ -12,48 +15,58 @@ import * as C from '../utils/constants';
 export function substructureSearchDialog(col: DG.Column): void {
   const units = col.getTag(DG.TAGS.UNITS);
   const separator = col.getTag(C.TAGS.SEPARATOR);
-  const notations = [NOTATION.FASTA, NOTATION.SEPARATOR];
+  // const notations = [NOTATION.FASTA, NOTATION.SEPARATOR, NOTATION.HELM];
 
   const substructureInput = ui.textInput('Substructure', '');
-  const notationInput = ui.choiceInput('Notation', units, notations);
+
+  const editHelmLink = ui.link('Edit helm', async () => {
+    updateDivInnerHTML(inputsDiv, grid.root);
+    await ui.tools.waitForElementInDom(grid.root);
+    setTimeout(() => {
+      grid.cell('substr_helm', 0).element.children[0].dispatchEvent(new KeyboardEvent('keydown', {key: 'Enter'}));
+    }, 100);
+  });
+
+  const df = DG.DataFrame.create(1);
+  df.columns.addNewString('substr_helm').init((i) => '');
+  df.col('substr_helm')!.semType = col.semType;
+  df.col('substr_helm')!.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+  const grid = df.plot.grid();
   const separatorInput = ui.textInput('Separator', separator);
 
-  // hide the separator input for non-SEPARATOR target notations
-  const toggleSeparator = () => {
-    if (notationInput.value !== NOTATION.SEPARATOR)
-      separatorInput.root.hidden = true;
-    else
-      separatorInput.root.hidden = false;
-  };
+  const inputsDiv = ui.div();
 
-  toggleSeparator();
+  const inputs = units === NOTATION.HELM ? ui.divV([editHelmLink]) :
+    units === NOTATION.SEPARATOR ? ui.inputs([substructureInput, separatorInput]) :
+      ui.inputs([substructureInput]);
 
-  notationInput.onChanged(() => {
-    toggleSeparator();
-  });
+  updateDivInnerHTML(inputsDiv, inputs);
 
   ui.dialog('Substructure search')
-    .add(ui.inputs([
-      substructureInput,
-      notationInput,
-      separatorInput
+    .add(ui.divV([
+      ui.divText(`Notation: ${units}`),
+      inputsDiv
     ]))
-    .onOK(() => {
-      let substructure = substructureInput.value;
-      if (notationInput.value !== NOTATION.FASTA && separatorInput.value !== separator)
+    .onOK(async () => {
+      let substructure = units === NOTATION.HELM ? df.get('substr_helm', 0) : substructureInput.value;
+      if (units === NOTATION.SEPARATOR && separatorInput.value !== separator && separatorInput.value !== '')
         substructure = substructure.replaceAll(separatorInput.value, separator);
       const matchesColName = `Matches: ${substructure}`;
       const colExists = col.dataFrame.columns.names()
         .filter((it) => it.toLocaleLowerCase() === matchesColName.toLocaleLowerCase()).length > 0;
       if (!colExists) {
-        const matches = substructureSearch(substructure, col);
+        let matches: BitSet;
+        if (units === NOTATION.HELM)
+          matches = await helmSubstructureSearch(substructure, col);
+        else
+          matches = linearSubstructureSearch(substructure, col);
         col.dataFrame.columns.add(DG.Column.fromBitSet(matchesColName, matches));
       } else { grok.shell.warning(`Search ${substructure} is already performed`); }
     })
     .show();
 }
 
-export function substructureSearch(substructure: string, col: DG.Column): DG.BitSet {
+export function linearSubstructureSearch(substructure: string, col: DG.Column): DG.BitSet {
   const lowerCaseSubstr = substructure.toLowerCase();
   const resultArray = DG.BitSet.create(col.length);
   for (let i = 0; i < col.length; i++) {
@@ -63,3 +76,19 @@ export function substructureSearch(substructure: string, col: DG.Column): DG.Bit
   }
   return resultArray;
 }
+
+async function helmSubstructureSearch(substructure: string, col: DG.Column): Promise<BitSet> {
+  const helmColWithSubstructure = DG.Column.string('helm', col.length + 1)
+    .init((i) => i === col.length ? substructure : col.get(i));
+  helmColWithSubstructure.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+  const monomericMolsCol = await getMonomericMols(helmColWithSubstructure, true);
+  const molSubstructure = monomericMolsCol.get(col.length);
+  const monomericMolsDf = DG.DataFrame.fromColumns([monomericMolsCol]);
+  monomericMolsDf.rows.removeAt(col.length);
+  const matchesCol = await grok.functions.call('Chem:searchSubstructure', {
+    molStringsColumn: monomericMolsDf.columns.byIndex(0),
+    molString: molSubstructure,
+    molBlockFailover: '',
+  });
+  return matchesCol.get(0);
+}

package/src/utils/cell-renderer.ts

@@ -228,7 +228,9 @@ export class MonomerCellRenderer extends DG.GridCellRenderer {
     g.textAlign = 'center';
 
     const palette = getPaletteByType(gridCell.cell.column.getTag(C.TAGS.ALPHABET));
-    const s: string = gridCell.cell.value || '-';
+    const s: string = gridCell.cell.value;
+    if (!s)
+      return;
     const color = palette.get(s);
 
     g.fillStyle = color;
@@ -271,7 +273,7 @@ export class MacromoleculeDifferenceCellRenderer extends DG.GridCellRenderer {
     const splitter = bio.getSplitter(units, separator);
     const subParts1 = splitter(s1);
     const subParts2 = splitter(s2);
-    drawMoleculeDifferenceOnCanvas(g, x, y, w, h, subParts1, subParts2, units, separator);
+    drawMoleculeDifferenceOnCanvas(g, x, y, w, h, subParts1, subParts2, units);
   }
 }
 

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

@@ -0,0 +1,151 @@
+/**
+ * Macromolecules substructure filter that uses Datagrok's collaborative filtering.
+ * 1. On onRowsFiltering event, only FILTER OUT rows that do not satisfy this filter's criteria
+ * 2. Call dataFrame.rows.requestFilter when filtering criteria changes.
+ * */
+
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import wu from 'wu';
+import {linearSubstructureSearch} from '../substructure-search/substructure-search';
+import {Subject, Subscription} from 'rxjs';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/units-handler';
+import * as C from '../utils/constants';
+
+export class BioSubstructureFilter extends DG.Filter {
+  bioFilter: FastaFilter | SeparatorFilter | null = null;
+  bitset: DG.BitSet | null = null;
+  loader: HTMLDivElement = ui.loader();
+  onBioFilterChangedSubs?: Subscription;
+
+  get calculating(): boolean { return this.loader.style.display == 'initial'; }
+  set calculating(value: boolean) { this.loader.style.display = value ? 'initial' : 'none'; }
+
+  get filterSummary(): string {
+    return this.bioFilter!.substructure;
+  }
+
+  get isFiltering(): boolean {
+    return super.isFiltering && this.bioFilter!.substructure !== '';
+  }
+
+  get isReadyToApplyFilter(): boolean {
+    return !this.calculating && this.bitset != null;
+  }
+
+  constructor() {
+    super();
+    this.root = ui.divV([]);
+    this.calculating = false;
+  }
+
+  attach(dataFrame: DG.DataFrame): void {
+    super.attach(dataFrame);
+    this.column = dataFrame.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
+    this.columnName = this.column?.name;
+    const notation = this.column?.getTag(DG.TAGS.UNITS);
+    this.bioFilter = notation === NOTATION.FASTA ?
+      new FastaFilter() : new SeparatorFilter(this.column!.getTag(C.TAGS.SEPARATOR));
+    this.root.appendChild(this.bioFilter!.filterPanel);
+    this.root.appendChild(this.loader);
+
+    this.onBioFilterChangedSubs?.unsubscribe();
+    const onChangedEvent: any = this.bioFilter.onChanged;
+    this.onBioFilterChangedSubs = onChangedEvent.subscribe(async (_: any) => await this._onInputChanged());
+  }
+
+  detach() {
+    super.detach();
+  }
+
+  applyFilter(): void {
+    if (this.bitset && !this.isDetached)
+      this.dataFrame?.filter.and(this.bitset);
+  }
+
+  /** Override to save filter state. */
+  saveState(): any {
+    const state = super.saveState();
+    state.bioSubstructure = this.bioFilter?.substructure;
+    return state;
+  }
+
+  /** Override to load filter state. */
+  applyState(state: any): void {
+    super.applyState(state);
+    if (state.bioSubstructure)
+      this.bioFilter!.substructureInput.value = state.bioSubstructure;
+
+    const that = this;
+    if (state.bioSubstructure)
+      setTimeout(function() { that._onInputChanged(); }, 1000);
+  }
+
+  /**
+    * Performs the actual filtering
+    * When the results are ready, triggers `rows.requestFilter`, which in turn triggers `applyFilter`
+    * that would simply apply the bitset synchronously.
+    */
+  async _onInputChanged(): Promise<void> {
+    if (!this.isFiltering) {
+      this.bitset = null;
+      this.dataFrame?.rows.requestFilter();
+    } else if (wu(this.dataFrame!.rows.filters).has(`${this.columnName}: ${this.filterSummary}`)) {
+      // some other filter is already filtering for the exact same thing
+      return;
+    } else {
+      this.calculating = true;
+      try {
+        this.bitset = linearSubstructureSearch(this.bioFilter!.substructure, this.column!);
+        this.calculating = false;
+        this.dataFrame?.rows.requestFilter();
+      } finally {
+        this.calculating = false;
+      }
+    }
+  }
+}
+
+class FastaFilter {
+  onChanged: Subject<any> = new Subject<any>();
+  substructureInput: DG.InputBase<string> = ui.stringInput('', '', () => {
+    this.onChanged.next();
+  }, {placeholder: 'Substructure'});
+
+  constructor() {
+  }
+
+  get filterPanel() {
+    return this.substructureInput.root;
+  }
+
+  get substructure() {
+    return this.substructureInput.value;
+  }
+}
+
+class SeparatorFilter extends FastaFilter {
+  separatorInput: DG.InputBase<string> = ui.stringInput('', '', () => {
+    this.onChanged.next();
+  }, {placeholder: 'Separator'});
+  colSeparator = '';
+
+  constructor(separator: string) {
+    super();
+    this.colSeparator = separator;
+    this.separatorInput.value = separator;
+  }
+
+  get filterPanel() {
+    return ui.divV([
+      this.substructureInput.root,
+      this.separatorInput.root
+    ]);
+  }
+
+  get substructure() {
+    return this.separatorInput.value && this.separatorInput.value !== this.colSeparator ?
+      this.substructureInput.value.replaceAll(this.separatorInput.value, this.colSeparator):
+      this.substructureInput.value;
+  }
+}