@datagrok/bio 2.8.4 → 2.9.0

package/dockerfiles/Dockerfile

@@ -24,12 +24,12 @@ RUN savedAptMark="$(apt-mark showmanual)" ; \
     ; \
     apt-mark auto '.*' > /dev/null ; \
     [ -z "$savedAptMark" ] || apt-mark manual $savedAptMark ; \
-	wget https://mafft.cbrc.jp/alignment/software/mafft_7.520-1_amd64.deb -O mafft.deb; \
-	apt install -y ./mafft.deb; \
-	rm -rf mafft.deb; \
+    wget https://mafft.cbrc.jp/alignment/software/mafft_7.520-1_amd64.deb -O mafft.deb; \
+    apt install -y ./mafft.deb; \
+    rm -rf mafft.deb; \
     wget https://github.com/Merck/PepSeA/archive/refs/heads/main.zip -O PepSeA.zip; \
     unzip -q PepSeA.zip -d /opt ; \
-	rm -rf PepSeA.zip; \
+    rm -rf PepSeA.zip; \
     chown -R grok:grok /opt/PepSeA-main ; \
     apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false ; \
     apt-get clean ; \
@@ -57,6 +57,7 @@ def distout():\n\
 \n\
     return distout_output\n' >> /opt/PepSeA-main/alignment/api.py;
 
+# It is important to run docker container as user and not as root
 USER grok:grok
 
 # Command source does not work for Docker, cause it will apply only to one layer

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.8.4",
+  "version": "2.9.0",
   "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",
@@ -34,14 +34,14 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.34.3",
+    "@datagrok-libraries/bio": "^5.37.0",
     "@datagrok-libraries/chem-meta": "^1.0.1",
     "@datagrok-libraries/ml": "^6.3.39",
     "@datagrok-libraries/tutorials": "^1.3.6",
     "@datagrok-libraries/utils": "^4.0.17",
     "cash-dom": "^8.0.0",
     "css-loader": "^6.7.3",
-    "datagrok-api": "^1.13.3",
+    "datagrok-api": "^1.16.0",
     "dayjs": "^1.11.4",
     "fastest-levenshtein": "^1.0.16",
     "openchemlib": "6.0.1",

package/src/analysis/sequence-activity-cliffs.ts

@@ -7,7 +7,9 @@ import {getSimilarityFromDistance} from '@datagrok-libraries/ml/src/distance-met
 import {AvailableMetrics, DistanceMetricsSubjects, StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
 import {drawMoleculeDifferenceOnCanvas} from '../utils/cell-renderer';
 import {invalidateMols, MONOMERIC_COL_TAGS} from '../substructure-search/substructure-search';
-import {getSplitter, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 
 export async function getDistances(col: DG.Column, seq: string): Promise<Array<number>> {
   const stringArray = col.toList();
@@ -103,12 +105,11 @@ export function createPropPanelElement(params: ITooltipAndPanelParams): HTMLDivE
   });
 
   const molDifferences: { [key: number]: HTMLCanvasElement } = {};
-  const units = params.seqCol.getTag(DG.TAGS.UNITS);
-  const separator = params.seqCol.getTag(bioTAGS.separator);
-  const splitter = getSplitter(units, separator);
+  const uh = UnitsHandler.getOrCreate(params.seqCol);
+  const splitter = uh.getSplitter();
   const subParts1 = splitter(sequencesArray[0]);
   const subParts2 = splitter(sequencesArray[1]);
-  const canvas = createDifferenceCanvas(subParts1, subParts2, units, molDifferences);
+  const canvas = createDifferenceCanvas(subParts1, subParts2, uh.units, molDifferences);
   propPanel.append(ui.div(canvas, {style: {width: '300px', overflow: 'scroll'}}));
 
   propPanel.append(createDifferencesWithPositions(molDifferences));
@@ -127,8 +128,8 @@ function createPropPanelField(name: string, value: number): HTMLDivElement {
 }
 
 export function createDifferenceCanvas(
-  subParts1: string[],
-  subParts2: string[],
+  subParts1: ISeqSplitted,
+  subParts2: ISeqSplitted,
   units: string,
   molDifferences: { [key: number]: HTMLCanvasElement }): HTMLCanvasElement {
   const canvas = document.createElement('canvas');

package/src/analysis/sequence-similarity-viewer.ts

@@ -7,7 +7,6 @@ import {getMonomericMols} from '../calculations/monomerLevelMols';
 import {createDifferenceCanvas, createDifferencesWithPositions} from './sequence-activity-cliffs';
 import {updateDivInnerHTML} from '../utils/ui-utils';
 import {Subject} from 'rxjs';
-import {TAGS as bioTAGS, getSplitter} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {calcMmDistanceMatrix, dmLinearIndex} from './workers/mm-distance-worker-creator';
 import {calculateMMDistancesArray} from './workers/mm-distance-array-service';
@@ -106,9 +105,10 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
     const linearizeFunc = dmLinearIndex(len);
     // array that keeps track of the indexes and scores together
     const indexWScore = Array(len).fill(0)
-      .map((_, i) => ({idx: i, score: i === this.targetMoleculeIdx ? 1 :
-        this.preComputeDistanceMatrix ? 1 - this.mmDistanceMatrix[linearizeFunc(this.targetMoleculeIdx, i)] :
-          1 - distanceArray[i]
+      .map((_, i) => ({
+        idx: i, score: i === this.targetMoleculeIdx ? 1 :
+          this.preComputeDistanceMatrix ? 1 - this.mmDistanceMatrix[linearizeFunc(this.targetMoleculeIdx, i)] :
+            1 - distanceArray[i]
       }));
     indexWScore.sort((a, b) => b.score - a.score);
     // get the most similar molecules
@@ -122,12 +122,12 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
     const propPanel = ui.div();
     const molDifferences: { [key: number]: HTMLCanvasElement } = {};
     const molColName = this.molCol?.name!;
-    const units = resDf.col(molColName)!.getTag(DG.TAGS.UNITS);
-    const separator = resDf.col(molColName)!.getTag(bioTAGS.separator);
-    const splitter = getSplitter(units, separator);
+    const col = resDf.col(molColName)!;
+    const uh = UnitsHandler.getOrCreate(col);
+    const splitter = uh.getSplitter();
     const subParts1 = splitter(this.moleculeColumn!.get(this.targetMoleculeIdx));
     const subParts2 = splitter(resDf.get(molColName, resDf.currentRowIdx));
-    const canvas = createDifferenceCanvas(subParts1, subParts2, units, molDifferences);
+    const canvas = createDifferenceCanvas(subParts1, subParts2, uh.units, molDifferences);
     propPanel.append(ui.div(canvas, {style: {width: '300px', overflow: 'scroll'}}));
     if (subParts1.length !== subParts2.length) {
       propPanel.append(ui.divV([

package/src/apps/web-logo-app.ts

@@ -2,7 +2,12 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import wu from 'wu';
+
 import {IWebLogoViewer} from '@datagrok-libraries/bio/src/viewers/web-logo';
+
+import {PROPS as wlPROPS} from '../viewers/web-logo-viewer';
+
 import {_package} from '../package';
 
 export class WebLogoApp {
@@ -11,7 +16,7 @@ export class WebLogoApp {
   df: DG.DataFrame;
   view: DG.TableView;
 
-  constructor() {}
+  constructor(private readonly urlParams: URLSearchParams) {}
 
   async init(df: DG.DataFrame, funcName: string): Promise<void> {
     this._funcName = funcName;
@@ -23,12 +28,27 @@ export class WebLogoApp {
   // -- View --
 
   async buildView(): Promise<void> {
-    this.view = grok.shell.addTableView(this.df);
-    this.view.path = this.view.basePath = `func/${_package.name}.${this._funcName}`;
+    const urlParamsTxt = wu(this.urlParams.entries())
+      .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+      .toArray().join('&');
 
-    const viewer: DG.Viewer & IWebLogoViewer = (await this.view.dataFrame.plot.fromType('WebLogo', {
-      sequenceColumnName: 'sequence',
-    }));
+    this.view = grok.shell.addTableView(this.df);
+    this.view.path = this.view.basePath = `func/${_package.name}.${this._funcName}?${urlParamsTxt}`;
+
+    const options: { [p: string]: any } = {sequenceColumnName: 'sequence'};
+    for (const [optName, optValue] of this.urlParams.entries()) {
+      switch (optName) {
+        // boolean
+        case wlPROPS.fixWidth:
+        case wlPROPS.fitArea:
+          options[optName] = ((v) => { return ['1', 'on', 'true'].includes(v.toLowerCase()); })(optValue);
+          break;
+        default:
+          options[optName] = optValue;
+      }
+    }
+    const viewer: DG.Viewer & IWebLogoViewer = (await this.view.dataFrame.plot
+      .fromType('WebLogo', options)) as DG.Viewer & IWebLogoViewer;
     this.view.dockManager.dock(viewer, DG.DOCK_TYPE.DOWN, null, 'WebLogo', 0.35);
   }
 }

package/src/calculations/monomerLevelMols.ts

@@ -1,9 +1,12 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+
+import wu from 'wu';
+
 import {getHelmMonomers} from '../package';
-import {TAGS as bioTAGS, getSplitter, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 
 const V2000_ATOM_NAME_POS = 31;
 
@@ -27,7 +30,7 @@ export async function getMonomericMols(
   } else {
     molV3000Array = new Array<string>(mcol.length);
     for (let i = 0; i < mcol.length; i++) {
-      const sequenceMonomers = uh.splitted[i].filter((it) => it !== '');
+      const sequenceMonomers = wu(uh.splitted[i]).filter((it) => it !== '').toArray();
       const molV3000 = molV3000FromNonHelmSequence(sequenceMonomers, monomersDict, pattern);
       molV3000Array[i] = molV3000;
     }
@@ -36,7 +39,7 @@ export async function getMonomericMols(
 }
 
 function molV3000FromNonHelmSequence(
-  monomers: Array<string>, monomersDict: Map<string, string>, pattern: boolean = false) {
+  monomers: ISeqSplitted, monomersDict: Map<string, string>, pattern: boolean = false) {
   let molV3000 = `
   Datagrok macromolecule handler
 

package/src/package-test.ts

@@ -28,6 +28,7 @@ import './tests/to-atomic-level-tests';
 import './tests/mm-distance-tests';
 import './tests/activity-cliffs-tests';
 import './tests/sequence-space-test';
+import './tests/scoring';
 
 
 export const _package = new DG.Package();

package/src/package-types.ts

@@ -14,7 +14,6 @@ export const enum BioPackagePropertiesNames {
 
 
 export class BioPackageProperties extends Map<string, any> {
-
   private _onPropertyChanged: Subject<string> = new Subject<string>();
   public get onPropertyChanged(): Observable<string> { return this._onPropertyChanged; }
 

package/src/package.ts

@@ -21,7 +21,7 @@ import {removeEmptyStringRows} from '@datagrok-libraries/utils/src/dataframe-uti
 
 import {SequenceSimilarityViewer} from './analysis/sequence-similarity-viewer';
 import {SequenceDiversityViewer} from './analysis/sequence-diversity-viewer';
-import {substructureSearchDialog} from './substructure-search/substructure-search';
+import {SubstructureSearchDialog} from './substructure-search/substructure-search';
 import {saveAsFastaUI} from './utils/save-as-fasta';
 import {BioSubstructureFilter} from './widgets/bio-substructure-filter';
 import {delay} from '@datagrok-libraries/utils/src/test';
@@ -40,10 +40,11 @@ import {
   getLibFileNameList,
   getLibraryPanelUI
 } from './utils/monomer-lib';
-import {getMacromoleculeColumn} from './utils/ui-utils';
+import {getMacromoleculeColumns} from './utils/ui-utils';
 import {DimReductionMethods, ITSNEOptions, IUMAPOptions} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {SequenceSpaceFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/seq-space-editor';
 import {ActivityCliffsFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/activity-cliffs-editor';
+import {SCORE, calculateScores} from '@datagrok-libraries/bio/src/utils/macromolecule/scoring';
 
 import {demoBio01UI} from './demo/bio01-similarity-diversity';
 import {demoBio01aUI} from './demo/bio01a-hierarchical-clustering-and-sequence-space';
@@ -602,7 +603,7 @@ export function importBam(fileContent: string): DG.DataFrame [] {
 //top-menu: Bio | Convert | Notation...
 //name: convertDialog
 export function convertDialog() {
-  const col = getMacromoleculeColumn();
+  const col = getMacromoleculeColumns()[0];
   convert(col);
 }
 
@@ -734,12 +735,52 @@ export function diversitySearchTopMenu() {
   view.dockManager.dock(viewer, 'down');
 }
 
-//top-menu: Bio | Search | Substructure...
-//name: bioSubstructureSearch
-//description: Finds sequence with the given subsequence
-export function bioSubstructureSearch(): void {
-  const col = getMacromoleculeColumn();
-  substructureSearchDialog(col);
+//name: SearchSubsequenceEditor
+//tags: editor
+//input: funccall call
+export function searchSubsequenceEditor(call: DG.FuncCall) {
+  const columns = getMacromoleculeColumns();
+  if (columns.length === 1)
+    call.func.prepare({macromolecules: columns[0]}).call(true);
+  else
+    new SubstructureSearchDialog(columns);
+}
+
+//top-menu: Bio | Search | Subsequence...
+//name: Subsequence Search
+//input: column macromolecules
+//editor: Bio:SearchSubsequenceEditor
+export function SubsequenceSearchTopMenu(macromolecules: DG.Column): void {
+  grok.shell.tv.getFiltersGroup({createDefaultFilters: false}).updateOrAdd({
+    type: 'Bio:bioSubstructureFilter',
+    column: macromolecules.name,
+    columnName: macromolecules.name,
+  });
+  grok.shell.tv.grid.scrollToCell(macromolecules, 0);
+}
+
+//top-menu: Bio | Caclulate | Identity...
+//name: Identity Scoring
+//description: Adds a column with fraction of matching monomers
+//input: dataframe table [Table containing Macromolecule column]
+//input: column macromolecules {semType: Macromolecule} [Sequences to score]
+//input: string reference [Sequence, matching column format]
+//output: column scores
+export async function sequenceIdentityScoring(table: DG.DataFrame, macromolecule: DG.Column, reference: string): Promise<DG.Column<number>> {
+  const scores = calculateScores(table, macromolecule, reference, SCORE.IDENTITY);
+  return scores;
+}
+
+//top-menu: Bio | Caclulate | Similarity...
+//name: Similarity Scoring
+//description: Adds a column with similarity scores, calculated as sum of monomer fingerprint similarities
+//input: dataframe table [Table containing Macromolecule column]
+//input: column macromolecules {semType: Macromolecule} [Sequences to score]
+//input: string reference [Sequence, matching column format]
+//output: column scores
+export async function sequenceSimilarityScoring(table: DG.DataFrame, macromolecule: DG.Column, reference: string): Promise<DG.Column<number>> {
+  const scores = calculateScores(table, macromolecule, reference, SCORE.SIMILARITY);
+  return scores;
 }
 
 //name: saveAsFasta
@@ -764,7 +805,8 @@ export function bioSubstructureFilter(): BioSubstructureFilter {
 export async function webLogoLargeApp(): Promise<void> {
   const pi = DG.TaskBarProgressIndicator.create('WebLogo');
   try {
-    const app = new WebLogoApp();
+    const urlParams = new URLSearchParams(window.location.search);
+    const app = new WebLogoApp(urlParams);
     const df: DG.DataFrame = await _package.files.readCsv('data/sample_PT_100000x5.csv');
     await grok.data.detectSemanticTypes(df);
     await app.init(df, 'webLogoLargeApp');

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

@@ -17,64 +17,93 @@ export const enum MONOMERIC_COL_TAGS {
 
 const SUBSTR_HELM_COL_NAME = 'substr_helm';
 
-/**
- * Searches substructure in each row of Macromolecule column
- *
- * @param {DG.column} col Column with 'Macromolecule' semantic type
- */
-export function substructureSearchDialog(col: DG.Column<string>): void {
-  const units = col.getTag(DG.TAGS.UNITS);
-  const separator = col.getTag(bioTAGS.separator);
-  // const notations = [NOTATION.FASTA, NOTATION.SEPARATOR, NOTATION.HELM];
-
-  const substructureInput = ui.textInput('Substructure', '');
-
-  const editHelmLink = ui.link('Edit helm', async () => {
-    updateDivInnerHTML(inputsDiv, grid.root);
-    await ui.tools.waitForElementInDom(grid.root);
-    setTimeout(() => {
-      grid.cell(SUBSTR_HELM_COL_NAME, 0).element.children[0].dispatchEvent(
-        new KeyboardEvent('keydown', {key: 'Enter'}));
-    }, 100);
-  });
+export class SubstructureSearchDialog {
+  units: string;
+  separator: string;
+  inputsDiv: HTMLDivElement;
+  substructureInput: DG.InputBase<string>;
+  separatorInput: DG.InputBase<string>;
+  editHelmLink: HTMLAnchorElement;
+  columnsInput: DG.InputBase<DG.Column | null>;
+  grid: DG.Grid;
+  col: DG.Column;
+  dialog: DG.Dialog;
+
+  constructor(columns: DG.Column<string>[]) {
+    this.col = columns[0];
+    this.createUI();
+  }
+
+  editHelmLinkAction(): void {
+    updateDivInnerHTML(this.inputsDiv, this.grid.root);
+    ui.tools.waitForElementInDom(this.grid.root).then(() => {
+      setTimeout(() => {
+        this.grid.cell(SUBSTR_HELM_COL_NAME, 0).element.children[0].dispatchEvent(
+          new KeyboardEvent('keydown', {key: 'Enter'})
+        );
+      }, 100);
+    });
+  }
+
+  updateInputs(): void {
+    const selectedInput = this.units === NOTATION.HELM ? ui.divV([this.columnsInput, this.editHelmLink]) :
+      this.units === NOTATION.SEPARATOR ? ui.inputs([this.columnsInput, this.substructureInput, this.separatorInput]) :
+        ui.inputs([this.columnsInput, this.substructureInput]);
 
-  const df = DG.DataFrame.create(1);
-  df.columns.addNewString(SUBSTR_HELM_COL_NAME).init((_i) => '');
-  df.col(SUBSTR_HELM_COL_NAME)!.semType = col.semType;
-  df.col(SUBSTR_HELM_COL_NAME)!.setTag(DG.TAGS.UNITS, NOTATION.HELM);
-  const grid = df.plot.grid();
-  const separatorInput = ui.textInput('Separator', separator);
-
-  const inputsDiv = ui.div();
-
-  const inputs = units === NOTATION.HELM ? ui.divV([editHelmLink]) :
-    units === NOTATION.SEPARATOR ? ui.inputs([substructureInput, separatorInput]) :
-      ui.inputs([substructureInput]);
-
-  updateDivInnerHTML(inputsDiv, inputs);
-
-  ui.dialog('Substructure Search')
-    .add(ui.divV([
-      ui.divText(`Notation: ${units}`),
-      inputsDiv,
-    ]))
-    .onOK(async () => {
-      let substructure = units === NOTATION.HELM ? df.get(SUBSTR_HELM_COL_NAME, 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) {
+    updateDivInnerHTML(this.inputsDiv, selectedInput);
+  }
+
+  updateNotationDiv(): void {
+    this.units = this.col.getTag(DG.TAGS.UNITS);
+    this.separator = this.col.getTag(bioTAGS.separator);
+    const notationDiv = this.dialog.root.getElementsByClassName('notation-text')[0];
+    if (notationDiv)
+      notationDiv.textContent = `Notation: ${this.units}`;
+  }
+
+  createUI(): void {
+    const dataframe = grok.shell.tv.dataFrame;
+    const seqColOptions = {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE};
+    this.columnsInput = ui.columnInput('Column', dataframe, this.col, (column: DG.Column) => {
+      this.col = column;
+      this.updateNotationDiv();
+      this.updateInputs();
+    }, seqColOptions);
+
+    this.substructureInput = ui.stringInput('Substructure', '');
+
+    this.editHelmLink = ui.link('Edit helm', () => this.editHelmLinkAction(), undefined, {style: {position: 'relative', left: '95px'}});
+
+    const df = DG.DataFrame.create(1);
+    df.columns.addNewString(SUBSTR_HELM_COL_NAME).init((_i) => '');
+    df.col(SUBSTR_HELM_COL_NAME)!.semType = this.col.semType;
+    df.col(SUBSTR_HELM_COL_NAME)!.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+    this.grid = df.plot.grid();
+    this.separatorInput = ui.stringInput('Separator', this.separator);
+
+    this.inputsDiv = ui.div();
+    this.units = this.col.getTag(DG.TAGS.UNITS);
+    this.separator = this.col.getTag(bioTAGS.separator);
+    this.updateInputs();
+
+    this.dialog = ui.dialog('Substructure Search')
+      .add(ui.divV([
+        ui.divText(`Notation: ${this.units}`, 'notation-text'),
+        this.inputsDiv,
+      ]))
+      .onOK(async () => {
+        let substructure = this.units === NOTATION.HELM ? df.get(SUBSTR_HELM_COL_NAME, 0) : this.substructureInput.value;
+        if (this.units === NOTATION.SEPARATOR && this.separatorInput.value !== this.separator && this.separatorInput.value !== '')
+          substructure = substructure.replaceAll(this.separatorInput.value, this.separator);
         let matches: DG.BitSet;
-        if (units === NOTATION.HELM)
-          matches = await helmSubstructureSearch(substructure, col);
+        if (this.units === NOTATION.HELM)
+          matches = await helmSubstructureSearch(substructure, this.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();
+          matches = linearSubstructureSearch(substructure, this.col);
+        this.col.dataFrame.filter.and(matches);
+      })
+      .show();
+  }
 }
 
 export function linearSubstructureSearch(substructure: string, col: DG.Column<string>, separator?: string): DG.BitSet {

package/src/tests/activity-cliffs-tests.ts

@@ -47,5 +47,5 @@ category('activityCliffs', async () => {
     viewList.push(actCliffsTableViewWithEmptyRows);
 
     await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 3, DimReductionMethods.UMAP, 'sequence');
-  });
+  }, {skipReason: 'GROK-13851: Unhandled exceptions'});
 });

package/src/tests/converters-test.ts

@@ -136,7 +136,7 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$$`,
     return function(srcCol: DG.Column): DG.Column {
       const converter = new NotationConverter(srcCol);
       const resCol = converter.convert(tgtNotation, tgtSeparator);
-      expect(resCol.getTag('units'), tgtNotation);
+      expect(resCol.getTag(DG.TAGS.UNITS), tgtNotation);
       return resCol;
     };
   }

package/src/tests/detectors-tests.ts

@@ -274,13 +274,13 @@ MWRSWY-CKHP`;
     await _testDf(readSamples(Samples.fastaCsv), {
       'Sequence': new PosCol(NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false),
     });
-  });
+  }, {skipReason: 'GROK-13851: Unhandled exceptions'});
 
   test('samplesFastaFasta', async () => {
     await _testDf(readSamples(Samples.fastaFasta), {
       'sequence': new PosCol(NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.PT, 20, false),
     });
-  });
+  }, {skipReason: 'GROK-13851: Unhandled exceptions'});
 
   // peptidesComplex contains monomers with spaces in AlignedSequence columns, which are forbidden
   // test('samplesPeptidesComplexPositiveAlignedSequence', async () => {

package/src/tests/msa-tests.ts

@@ -7,7 +7,6 @@ import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-librarie
 import {runKalign} from '../utils/multiple-sequence-alignment';
 import {multipleSequenceAlignmentUI} from '../utils/multiple-sequence-alignment-ui';
 import {awaitContainerStart} from './utils';
-//import * as grok from 'datagrok-api/grok';
 
 category('MSA', async () => {
   //table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');
@@ -113,8 +112,8 @@ async function _testMsaIsCorrect(srcCsv: string, tgtCsv: string): Promise<void>
     srcCol.semType = semType;
 
   const tgtCol: DG.Column = tgtDf.getCol('seq')!;
-  const msaCol: DG.Column = await runKalign(srcCol, true);
-  expectArray(msaCol.toList(), tgtCol.toList());
+  const resCol: DG.Column = await runKalign(srcCol, true);
+  expectArray(resCol.toList(), tgtCol.toList());
 }
 
 async function _testMSAOnColumn(

package/src/tests/renderers-test.ts

@@ -1,6 +1,8 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
+import $ from 'cash-dom';
+
 import {category, expect, test, awaitCheck, delay} from '@datagrok-libraries/utils/src/test';
 
 import {importFasta} from '../package';
@@ -47,8 +49,12 @@ category('renderers', () => {
     await _selectRendererBySemType();
   });
 
-  test('setRendererManually', async () => {
-    await _setRendererManually();
+  test('setRendererManuallyBeforeAddColumn', async () => {
+    await _setRendererManuallyBeforeAddColumn();
+  }, {skipReason: 'GROK-11212'});
+
+  test('setRendererManuallyAfterAddColumn', async () => {
+    await _setRendererManuallyAfterAddColumn();
   }, {skipReason: 'GROK-11212'});
 
   async function _rendererMacromoleculeFasta() {
@@ -204,7 +210,7 @@ category('renderers', () => {
 
   /** GROK-11212 Do not overwrite / recalculate 'cell.renderer' tag that has been set programmatically
    * https://reddata.atlassian.net/browse/GROK-11212 */
-  async function _setRendererManually() {
+  async function _setRendererManuallyBeforeAddColumn() {
     const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
       ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
     seqDiffCol.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
@@ -227,4 +233,32 @@ category('renderers', () => {
         `instead of manual '${tgtCellRenderer}'.`);
     }
   }
+
+  /** GROK-11212 Do not overwrite / recalculate 'cell.renderer' tag that has been set programmatically
+   * https://reddata.atlassian.net/browse/GROK-11212 */
+  async function _setRendererManuallyAfterAddColumn() {
+    const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
+      ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
+    seqDiffCol.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
+    seqDiffCol.setTag(bioTAGS.separator, '/');
+    seqDiffCol.setTag(bioTAGS.aligned, 'SEQ');
+    seqDiffCol.setTag(bioTAGS.alphabet, 'UN');
+    seqDiffCol.setTag(bioTAGS.alphabetIsMultichar, 'true');
+    seqDiffCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    const tgtCellRenderer = 'MacromoleculeDifference';
+    const df = DG.DataFrame.fromColumns([seqDiffCol]);
+    await grok.data.detectSemanticTypes(df);
+    const tv = grok.shell.addTableView(df);
+    await awaitCheck(() => $(tv.root).find('.d4-grid canvas').length > 0, 'View grid canvas not found', 200);
+
+    seqDiffCol.setTag(DG.TAGS.CELL_RENDERER, tgtCellRenderer);
+    await awaitCheck(() => $(tv.root).find('.d4-grid canvas').length > 0, 'View grid canvas not found', 200);
+
+    const resCellRenderer = seqDiffCol.getTag(DG.TAGS.CELL_RENDERER);
+    if (resCellRenderer !== tgtCellRenderer) { // this is value of MacromoleculeDifferenceCR.cellType
+      throw new Error(`Tag 'cell.renderer' has been manually set to '${tgtCellRenderer}' for column ` +
+        `but after df was added as table, tag 'cell.renderer' has reset to '${resCellRenderer}' ` +
+        `instead of manual '${tgtCellRenderer}'.`);
+    }
+  }
 });

package/src/tests/scoring.ts

@@ -0,0 +1,38 @@
+import * as DG from 'datagrok-api/dg';
+
+import {category, test, expectFloat, before} from '@datagrok-libraries/utils/src/test';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {sequenceIdentityScoring, sequenceSimilarityScoring} from '../package';
+import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+category('Scoring', () => {
+  const sequence = 'sequence';
+  const expectedSimilarity = 'expected_similarity';
+  const expectedIdentity = 'expected_identity';
+  const table = DG.DataFrame.fromCsv(`${sequence},${expectedSimilarity},${expectedIdentity}
+  PEPTIDE1{Aca.Orn.gGlu.Pqa.D-His_1Bn.dH.hHis.4Abz.D-Tic.D-Dap.Y.Iva.meS.F.P.F.D-1Nal}$$$$,1.0,1.0
+  PEPTIDE1{Iva.Gly_allyl.gGlu.Pqa.D-Dip.dH.hHis.4Abz.D-aHyp.D-Dap.Y.Iva.I.Tyr_26diMe.P.Asu.meC}$$$$,0.68,0.53
+  PEPTIDE1{[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal]}$$$$V2.0,0.34,0.0
+  `);
+  const seqCol: DG.Column<string> = table.getCol(sequence);
+  seqCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+  seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+  const reference = seqCol.get(0)!;
+
+  before(async () => {
+    const monomerLibHelper = await getMonomerLibHelper();
+    await monomerLibHelper.loadLibraries(true);
+  });
+
+  test('Identity', async () => {
+    const scoresCol = await sequenceIdentityScoring(table, seqCol, reference);
+    for (let i = 0; i < scoresCol.length; i++)
+      expectFloat(scoresCol.get(i)!, table.get(expectedIdentity, i), 0.01, `Wrong identity score for sequence at position ${i}`);
+  });
+
+  test('Similarity', async () => {
+    const scoresCol = await sequenceSimilarityScoring(table, seqCol, reference);
+    for (let i = 0; i < scoresCol.length; i++)
+      expectFloat(scoresCol.get(i)!, table.get(expectedSimilarity, i), 0.01, `Wrong similarity score for sequence at position ${i}`);
+  });
+});