@datagrok/bio 2.4.16 → 2.4.18

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.4.16",
+  "version": "2.4.18",
   "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/analysis/sequence-activity-cliffs.ts

@@ -43,8 +43,8 @@ export async function getSimilaritiesMatrix(
 }
 
 export async function getChemSimilaritiesMatrix(dim: number, seqCol: DG.Column,
-  df: DG.DataFrame, colName: string, simArr: DG.Column[])
-  : Promise<DG.Column[]> {
+  df: DG.DataFrame, colName: string, simArr: (DG.Column | null)[])
+  : Promise<(DG.Column | null)[]> {
   if (seqCol.version !== seqCol.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION])
     await invalidateMols(seqCol, false);
   const fpDf = DG.DataFrame.create(seqCol.length);

package/src/analysis/sequence-space.ts

@@ -6,6 +6,7 @@ import {Matrix} from '@datagrok-libraries/utils/src/type-declarations';
 import BitArray from '@datagrok-libraries/utils/src/bit-array';
 import {ISequenceSpaceParams} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {invalidateMols, MONOMERIC_COL_TAGS} from '../substructure-search/substructure-search';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import * as grok from 'datagrok-api/grok';
 
 export interface ISequenceSpaceResult {
@@ -53,6 +54,23 @@ export async function sequenceSpaceByFingerprints(spaceParams: ISequenceSpacePar
   return result;
 }
 
+export async function getSequenceSpace(spaceParams: ISequenceSpaceParams): Promise<ISequenceSpaceResult> {
+  const uh = new UnitsHandler(spaceParams.seqCol);
+  if (uh.isFasta()) {
+    const distanceFName = uh.getDistanceFunctionName();
+    const sequenceSpaceResult = await reduceDimensinalityWithNormalization(
+      spaceParams.seqCol.toList(),
+      spaceParams.methodName,
+      distanceFName,
+      spaceParams.options);
+    console.log(sequenceSpaceResult);
+    const cols: DG.Column[] = spaceParams.embedAxesNames.map(
+      (name: string, index: number) => DG.Column.fromFloat32Array(name, sequenceSpaceResult.embedding[index]));
+    return {distance: sequenceSpaceResult.distance, coordinates: new DG.ColumnList(cols)};
+  } else {
+    return await sequenceSpaceByFingerprints(spaceParams);
+  }
+}
 
 export function getEmbeddingColsNames(df: DG.DataFrame) {
   const axes = ['Embed_X', 'Embed_Y'];

package/src/demo/bio01-similarity-diversity.ts

@@ -18,7 +18,7 @@ export async function demoBio01UI() {
   try {
     const demoScript = new DemoScript('Demo', 'Sequence similarity / diversity search');
     await demoScript
-      .step(`Loading DNA notation 'fasta'`, async () => {
+      .step(`Load DNA sequences`, async () => {
         grok.shell.windows.showContextPanel = false;
         grok.shell.windows.showProperties = false;
 
@@ -32,7 +32,7 @@ export async function demoBio01UI() {
         description: `Load dataset with macromolecules of 'fasta' notation, 'DNA' alphabet.`,
         delay: 1200
       })
-      .step('Sequence similarity search', async () => {
+      .step('Find the most similar sequences to the current one', async () => {
         const simViewer = await df.plot.fromType('Sequence Similarity Search', {
           moleculeColumnName: 'sequence',
           similarColumnLabel: 'Similar to current',
@@ -42,7 +42,7 @@ export async function demoBio01UI() {
         description: `Add 'Sequence Similarity Search' viewer.`,
         delay: 1600
       })
-      .step('Sequence diversity search', async () => {
+      .step('Explore most diverse sequences in a dataset', async () => {
         const divViewer = await df.plot.fromType('Sequence Diversity Search', {
           moleculeColumnName: 'sequence',
           diverseColumnLabel: 'Top diverse sequences of all data'
@@ -52,16 +52,16 @@ export async function demoBio01UI() {
         description: `Add 'Sequence Deversity Search' viewer.`,
         delay: 1600
       })
-      .step('Set current row 3', async () => {
+      .step('Choose another sequence for similarity search', async () => {
         df.currentRowIdx = 3;
       }, {
         description: 'Handling current row changed of data frame showing update of similar sequences.',
         delay: 1600,
       })
-      .step('Set current row 7', async () => {
+      .step('One more sequence for similarity search', async () => {
         df.currentRowIdx = 7;
       }, {
-        description: 'Changing current row to another.',
+        description: 'Just one more sequence to search similar ones.',
         delay: 1600,
       })
       .start();

package/src/demo/bio01a-hierarchical-clustering-and-sequence-space.ts

@@ -28,7 +28,7 @@ export async function demoBio01aUI() {
   try {
     const demoScript = new DemoScript('Demo', 'Exploring sequence space');
     await demoScript
-      .step(`Loading DNA notation 'fasta'`, async () => {
+      .step(`Load DNA sequences`, async () => {
         [df, treeHelper, dendrogramSvc] = await Promise.all([
           _package.files.readCsv(dataFn),
           getTreeHelper(),
@@ -43,13 +43,13 @@ export async function demoBio01aUI() {
         description: `Load dataset with macromolecules of 'fasta' notation, 'DNA' alphabet.`,
         delay: 1600,
       })
-      .step('Building sequence space', async () => {
+      .step('Build sequence space', async () => {
         spViewer = await demoSequenceSpace(view, df, seqColName, method);
       }, {
         description: `Reduce sequence space dimensionality to display on 2D representation.`,
         delay: 1600
       })
-      .step('Hierarchical clustering', async () => {
+      .step('Cluster sequences', async () => {
         const seqCol: DG.Column<string> = df.getCol(seqColName);
         const seqList = seqCol.toList();
         const distance: DistanceMatrix = DistanceMatrix.calc(seqList, (aSeq: string, bSeq: string) => {
@@ -62,7 +62,7 @@ export async function demoBio01aUI() {
         description: `Perform hierarchical clustering to reveal relationships between sequences.`,
         delay: 1600,
       })
-      .step('Selection', async () => {
+      .step('Select a sequence', async () => {
         df.selection.init((idx: number) => [15].includes(idx));
       }, {
         description: `Handling selection of data frame row reflecting on linked viewers.`,

package/src/demo/bio01b-hierarchical-clustering-and-activity-cliffs.ts

@@ -28,7 +28,7 @@ export async function demoBio01bUI() {
   try {
     const demoScript = new DemoScript('Demo', '');
     await demoScript
-      .step(`Loading DNA notation \'fasta\'`, async () => {
+      .step(`Load DNA sequences`, async () => {
         grok.shell.windows.showContextPanel = false;
         grok.shell.windows.showProperties = false;
 
@@ -48,7 +48,7 @@ export async function demoBio01bUI() {
         description: 'Load dataset with macromolecules of \'fasta\' notation, \'DNA\' alphabet.',
         delay: 1600,
       })
-      .step('Analyze for activity cliffs', async () => {
+      .step('Find activity cliffs', async () => {
         activityCliffsViewer = (await activityCliffs(
           df, df.getCol('Sequence'), df.getCol('Activity'),
           80, method)) as DG.ScatterPlotViewer;
@@ -62,7 +62,7 @@ export async function demoBio01bUI() {
         description: 'Reveal similar sequences with a cliff of activity.',
         delay: 1600
       })
-      .step('Hierarchical clustering', async () => {
+      .step('Cluster sequences', async () => {
         const seqCol: DG.Column<string> = df.getCol('sequence');
         const seqList = seqCol.toList();
         const distance: DistanceMatrix = DistanceMatrix.calc(seqList, (aSeq: string, bSeq: string) => {

package/src/demo/bio03-atomic-level.ts

@@ -0,0 +1,44 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+
+import {_package, toAtomicLevel} from '../package';
+import $ from 'cash-dom';
+import {handleError} from './utils';
+import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
+
+const dataFn: string = 'sample/sample_FASTA.csv';
+
+export async function demoBio03UI(): Promise<void> {
+  let df: DG.DataFrame;
+  let view: DG.TableView;
+
+  try {
+    await new DemoScript(
+      'Atomic Level',
+      'Atomic level structure of Macromolecules'
+    )
+      .step(`Loading Macromolecules notation 'Helm'`, async () => {
+        df = await _package.files.readCsv(dataFn);
+        view = grok.shell.addTableView(df);
+        for (let colI: number = 0; colI < view.grid.columns.length; colI++) {
+          const gCol: DG.GridColumn = view.grid.columns.byIndex(colI)!;
+          if (!(['Sequence', 'Activity'].includes(gCol.name))) gCol.visible = false;
+        }
+      }, {
+        description: `Load dataset with macromolecules of 'fasta' notation, 'PT' alphabet (protein, aminoacids).`,
+        delay: 1600,
+      })
+      .step('To atomic level', async () => {
+        const seqCol = df.getCol('Sequence');
+        await toAtomicLevel(df, seqCol);
+      }, {
+        description: 'Get atomic level structures of Macromolecules.',
+        delay: 1600,
+      })
+      .start();
+  } catch (err: any) {
+    handleError(err);
+  }
+}

package/src/demo/bio05-helm-msa-sequence-space.ts

@@ -26,7 +26,7 @@ export async function demoBio05UI(): Promise<void> {
   try {
     const demoScript = new DemoScript('Demo', 'MSA and composition analysis on Helm data.');
     await demoScript
-      .step(`Loading peptides notation 'HELM'`, async () => {
+      .step(`Load peptides with non-natural aminoacids in 'HELM' notation`, async () => {
         view = grok.shell.addTableView(df = await _package.files.readCsv(helmFn));
 
         grok.shell.windows.showContextPanel = false;
@@ -35,7 +35,7 @@ export async function demoBio05UI(): Promise<void> {
         description: 'Load dataset with macromolecules of \'Helm\' notation.',
         delay: 1600,
       })
-      .step('MSA on non-natural aminoacids with PepSeA', async () => {
+      .step('Align paptides with non-natural aminoacids with PepSeA', async () => {
         helmCol = df.getCol(helmColName);
         const method: string = pepseaMethods[0];
         const gapOpen: number = 1.53;
@@ -47,7 +47,7 @@ export async function demoBio05UI(): Promise<void> {
         description: 'Multiple sequence alignment (MSA) performed with PepSeA tool operating on non-natural aminoacids as well.',
         delay: 1600,
       })
-      .step('Building sequence space', async () => {
+      .step('Build sequence space', async () => {
         const method: string = 'UMAP';
         ssViewer = (await sequenceSpaceTopMenu(df, msaHelmCol,
           'UMAP', StringMetricsNames.Levenshtein, true)) as DG.ScatterPlotViewer;
@@ -56,7 +56,7 @@ export async function demoBio05UI(): Promise<void> {
         description: 'Reduce sequence space dimensionality to display on 2D representation.',
         delay: 1600
       })
-      .step('Composition analysis on MSA results', async () => {
+      .step('Analyse sequence composition', async () => {
         wlViewer = await df.plot.fromType('WebLogo', {
           sequenceColumnName: msaHelmColName,
           maxHeight: 50,

package/src/package.ts

@@ -38,7 +38,10 @@ import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {WebLogoViewer} from './viewers/web-logo-viewer';
 import {createJsonMonomerLibFromSdf, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
-import {LIB_PATH, LIB_STORAGE_NAME, MonomerLibHelper} from './utils/monomer-lib';
+import {
+  LIB_PATH, MonomerLibHelper,
+  LIB_STORAGE_NAME, LibSettings, getUserLibSettings, setUserLibSetting, getLibFileNameList
+} from './utils/monomer-lib';
 import {getMacromoleculeColumn} from './utils/ui-utils';
 import {ITSNEOptions, IUMAPOptions} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {SequenceSpaceFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/seq-space-editor';
@@ -46,10 +49,10 @@ import {ActivityCliffsFunctionEditor} from '@datagrok-libraries/ml/src/functionE
 import {demoBio01UI} from './demo/bio01-similarity-diversity';
 import {demoBio01aUI} from './demo/bio01a-hierarchical-clustering-and-sequence-space';
 import {demoBio01bUI} from './demo/bio01b-hierarchical-clustering-and-activity-cliffs';
+import {demoBio03UI} from './demo/bio03-atomic-level';
 import {demoBio05UI} from './demo/bio05-helm-msa-sequence-space';
 import {checkInputColumnUI} from './utils/check-input-column';
 import {multipleSequenceAlignmentUI} from './utils/multiple-sequence-alignment-ui';
-import { runKalign } from './utils/multiple-sequence-alignment';
 
 export const _package = new DG.Package();
 
@@ -150,25 +153,25 @@ export async function libraryPanel(seqColumn: DG.Column): Promise<DG.Widget> {
   //@ts-ignore
   const filesButton: HTMLButtonElement = ui.button('Manage', manageFiles);
   const divInputs: HTMLDivElement = ui.div();
-  const libFileNameList: string[] = (await grok.dapi.files.list(`${LIB_PATH}`, false, ''))
-    .map((it) => it.fileName);
+  const libFileNameList: string[] = await getLibFileNameList();
   const librariesUserSettingsSet: Set<string> = new Set<string>(Object.keys(
     await grok.dapi.userDataStorage.get(LIB_STORAGE_NAME, true)));
 
   let userStoragePromise: Promise<void> = Promise.resolve();
   for (const libFileName of libFileNameList) {
-    const libInput: DG.InputBase<boolean | null> = ui.boolInput(libFileName, librariesUserSettingsSet.has(libFileName),
+    const settings = await getUserLibSettings();
+    const libInput: DG.InputBase<boolean | null> = ui.boolInput(libFileName, !settings.exclude.includes(libFileName),
       () => {
         userStoragePromise = userStoragePromise.then(async () => {
           if (libInput.value == true) {
-            // Save checked library to user settings 'Libraries'
-            await grok.dapi.userDataStorage.postValue(LIB_STORAGE_NAME, libFileName, libFileName, true);
-            await MonomerLibHelper.instance.loadLibraries(); // from libraryPanel()
+            // Checked library remove from excluded list
+            settings.exclude = settings.exclude.filter((l) => l != libFileName);
           } else {
-            // Remove unchecked library from user settings 'Libraries'
-            await grok.dapi.userDataStorage.remove(LIB_STORAGE_NAME, libFileName, true);
-            await MonomerLibHelper.instance.loadLibraries(true); // from libraryPanel()
+            // Unchecked library add to excluded list
+            if (!settings.exclude.includes(libFileName)) settings.exclude.push(libFileName);
           }
+          await setUserLibSetting(settings);
+          await MonomerLibHelper.instance.loadLibraries(true); // from libraryPanel()
           grok.shell.info('Monomer library user settings saved.');
         });
       });
@@ -668,7 +671,7 @@ export function bioSubstructureFilter(): BioSubstructureFilter {
 // demoBio01
 //name: demoBioSimilarityDiversity
 //meta.demoPath: Bioinformatics | Similarity, Diversity
-//description:
+//description: Sequence similarity tracking and evaluation dataset diversity
 //meta.path: /apps/Tutorials/Demo/Bioinformatics/Similarity,%20Diversity
 export async function demoBioSimilarityDiversity(): Promise<void> {
   await demoBio01UI();
@@ -677,7 +680,7 @@ export async function demoBioSimilarityDiversity(): Promise<void> {
 // demoBio01a
 //name:demoBioSequenceSpace
 //meta.demoPath: Bioinformatics | Sequence Space
-//description:
+//description: Exploring sequence space of Macromolecules, comparison with hierarchical clustering results
 //meta.path: /apps/Tutorials/Demo/Bioinformatics/Sequence%20Space
 export async function demoBioSequenceSpace(): Promise<void> {
   await demoBio01aUI();
@@ -686,16 +689,25 @@ export async function demoBioSequenceSpace(): Promise<void> {
 // demoBio01b
 //name: demoBioActivityCliffs
 //meta.demoPath: Bioinformatics | Activity Cliffs
-//description:
+//description: Activity Cliffs analysis on Macromolecules data
 //meta.path: /apps/Tutorials/Demo/Bioinformatics/Activity%20Cliffs
 export async function demoBioActivityCliffs(): Promise<void> {
   await demoBio01bUI();
 }
 
+// demoBio03
+//name: demoBioAtomicLevel
+//meta.demoPath: Bioinformatics | Atomic Level
+//description: Atomic level structure of Macromolecules
+//meta.path: /apps/Tutorials/Demo/Bioinformatics/Atomic%20Level
+export async function demoBioAtomicLevel(): Promise<void> {
+  await demoBio03UI();
+}
+
 // demoBio05
 //name: demoBioHelmMsaSequenceSpace
 //meta.demoPath: Bioinformatics | Helm, MSA, Sequence Space
-//description:
+//description: MSA and composition analysis on Helm data
 //meta.path: /apps/Tutorials/Demo/Bioinformatics/Helm,%20MSA,%20Sequence%20Space
 export async function demoBioHelmMsaSequenceSpace(): Promise<void> {
   await demoBio05UI();

package/src/tests/monomer-libraries-tests.ts

@@ -27,8 +27,8 @@ category('monomerLibraries', () => {
     await grok.dapi.userDataStorage.put(LIB_STORAGE_NAME, {}, true);
     await monomerLibHelper.loadLibraries(true); // test defaultLib
 
-    // Currently default monomer lib is empty
+    // Currently default monomer lib set is of all files at LIB_PATH (at least HELMCoreLibrary.json)
     const currentMonomerLib = monomerLibHelper.getBioLib();
-    expect(currentMonomerLib.getTypes().length, 0);
+    expect(currentMonomerLib.getTypes().length > 0, true);
   });
 });

package/src/utils/monomer-lib.ts

@@ -15,6 +15,31 @@ export const LIB_STORAGE_NAME = 'Libraries';
 export const LIB_PATH = 'System:AppData/Bio/libraries/';
 export const LIB_DEFAULT: { [fileName: string]: string } = {'HELMCoreLibrary.json': 'HELMCoreLibrary.json'};
 
+/** Type for user settings of monomer library set to use. */
+export type LibSettings = {
+  exclude: string[],
+}
+
+export async function getLibFileNameList(): Promise<string[]> {
+  const res: string[] = (await grok.dapi.files.list(`${LIB_PATH}`, false, ''))
+    .map((it) => it.fileName);
+  return res;
+}
+
+export async function getUserLibSettings(): Promise<LibSettings> {
+  const resStr: string = await grok.dapi.userDataStorage.getValue(LIB_STORAGE_NAME, 'Settings', true);
+  const res: LibSettings = resStr ? JSON.parse(resStr) : {exclude: []};
+
+  // Fix empty object returned in case there is no settings stored for user
+  res.exclude = res.exclude instanceof Array ? res.exclude : [];
+
+  return res;
+}
+
+export async function setUserLibSetting(value: LibSettings): Promise<void> {
+  await grok.dapi.userDataStorage.postValue(LIB_STORAGE_NAME, 'Settings', JSON.stringify(value), true);
+}
+
 export class MonomerLib implements IMonomerLib {
   private _monomers: { [type: string]: { [name: string]: Monomer } } = {};
   private _onChanged = new Subject<any>();
@@ -104,11 +129,16 @@ export class MonomerLibHelper implements IMonomerLibHelper {
    */
   async loadLibraries(reload: boolean = false): Promise<void> {
     return this.loadLibrariesPromise = this.loadLibrariesPromise.then(async () => {
-      const userLibrariesSettings: string[] = Object.keys(await grok.dapi.userDataStorage.get(LIB_STORAGE_NAME, true));
-      const libs: IMonomerLib[] = await Promise.all(userLibrariesSettings.map((libFileName) => {
-        //TODO handle whether files are in place
-        return this.readLibrary(LIB_PATH, libFileName);
-      }));
+      const [libFileNameList, settings]: [string[], LibSettings] = await Promise.all([
+        getLibFileNameList(),
+        getUserLibSettings()
+      ]);
+      const libs: IMonomerLib[] = await Promise.all(libFileNameList
+        .filter((libFileName) => !settings.exclude.includes(libFileName))
+        .map((libFileName) => {
+          //TODO handle whether files are in place
+          return this.readLibrary(LIB_PATH, libFileName);
+        }));
       this._monomerLib.updateLibs(libs, reload);
     });
   }