@datagrok/bio 2.4.12 → 2.4.13

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.4.12",
+  "version": "2.4.13",
   "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",
@@ -17,6 +17,7 @@
     "@datagrok-libraries/bio": "^5.28.4",
     "@datagrok-libraries/chem-meta": "^1.0.1",
     "@datagrok-libraries/ml": "^6.3.16",
+    "@datagrok-libraries/tutorials": "^1.2.1",
     "@datagrok-libraries/utils": "^2.1.3",
     "cash-dom": "^8.0.0",
     "css-loader": "^6.7.3",
@@ -32,12 +33,12 @@
   "devDependencies": {
     "@types/node": "^17.0.24",
     "@types/wu": "latest",
-    "@typescript-eslint/eslint-plugin": "^4.20.0",
-    "@typescript-eslint/parser": "^4.20.0",
-    "eslint": "^7.23.0",
+    "@typescript-eslint/eslint-plugin": "latest",
+    "@typescript-eslint/parser": "latest",
+    "eslint": "latest",
     "eslint-config-google": "latest",
     "ts-loader": "^9.2.5",
-    "typescript": "^4.2.3",
+    "typescript": "^5.0.4",
     "webpack": "^5.76.0",
     "webpack-bundle-analyzer": "latest",
     "webpack-cli": "^4.6.0",

package/scripts/motif_generator.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+
+import random
+from math import sqrt
+import argparse
+import sys
+
+from typing import List, Tuple
+
+letter_choice_type = List[str]
+motif_template_type = List[letter_choice_type]
+
+default_alphabet = 'A,C,D,E,F,G,H,I,K,L,M,N,P,Q,R,S,T,V,W,Y'
+
+def meanrange(mean:int,disp:int) -> int:
+    return random.randint(mean - disp, mean + disp)
+
+def generate_modif_template(motif_length:int, alphabet:List[str], max_variants_cluster:int, prob_any:float=0.2) -> motif_template_type:  # Making a template to generate from it some random motifs
+    motif_template = []
+    for position in range(motif_length):
+        # Selecting letters for position i
+        if (0 < position < motif_length-1) and (random.random() <= prob_any):
+                letters = ['?'] # this stands for any symbol
+        else:
+            n_variants = random.randrange(max_variants_cluster) + 1
+            letters = [ random.choice(alphabet) for i in range(n_variants)]
+        motif_template.append(letters)
+    return motif_template
+    
+def generate_motif(template: motif_template_type, alphabet:List[str]) -> str:
+    # Sunbtituting the ? in template for any letter
+    template_with_any = [ (letters if not '?' in letters else alphabet) for letters in template ]
+    return ''.join([ random.choice(letters) for letters in template_with_any ])
+
+def motif_notation(motif_template: motif_template_type) -> str:
+    def motif_notation_code(letter_choice:letter_choice_type) -> str:
+        if len(letter_choice) == 1:
+            return(letter_choice[0])
+        else:
+            return f"[{''.join(letter_choice)}]"
+    
+    return ''.join([ motif_notation_code(letter_choice) for letter_choice in motif_template])
+
+def generate_random(n:int, alphabet:List[str]) -> str:
+    return ''.join([ random.choice(alphabet) for i in range(n) ])
+
+def make_cliff(motif_template:motif_template_type, alphabet:List[str] , motif:str) -> str:
+    # Selecting conservative letter in motif
+    pos = random.randrange(len(motif_template))
+    while '?' in motif_template[pos]:
+        pos = (pos + 1) % len(motif_template) # always will find letters since ends of motif can't be any symbol
+    outlier_letters = list(set(alphabet) - set (motif_template[pos]))
+    return motif[:pos] + random.choice(outlier_letters) + motif[pos+1:]
+    
+# ====================================================================================
+
+parser = argparse.ArgumentParser(prog='MotifSequencesGenerator',
+                    description='The program generates set of sequences containing sequence motifs for SAR fucntionality testing',
+                    epilog='Unitity support: Gennadii Zakharov ')
+
+parser.add_argument("-a", "--alphabet", type=str, default=default_alphabet, help="Alphabet to generate sequences, separated by comma",)
+parser.add_argument("-c", "--clusters", type=int, default=1, help="Number of clusters")
+parser.add_argument("-s", "--sequences", type=int, default=500, help="Number of sequences in each cluster",)
+parser.add_argument("-m,", "--motif", type=int, default=12, help="Average length of motif",)
+parser.add_argument("-r,", "--random", type=int, default=4, help="Average length of random sequence parts before and after motif",)
+parser.add_argument("-d,", "--dispersion", type=int, default=2, help="Variation of total sequence lengths",)
+
+parser.add_argument("--max-variants-position", type=int, default=3, help="maximum number of different letters in motif position",)
+parser.add_argument("--cliff-probability", type=float, default=0.01, help="Probabaility to make activity cliff of a sequence",)
+parser.add_argument("--cliff-strength", type=float, default=4.0, help="Strength of cliff",)
+
+args = parser.parse_args()
+
+alphabet:List[str] = args.alphabet.split(',')
+
+print('cluster\tsequence_id\tsequence\tactivity\tis_cliff')
+
+line_number = 0
+
+for n_cluster in range(args.clusters):
+    activity_average = random.random() * 10 
+    activity_dispersion = random.random()
+    
+    # Generatin motif template for cluster
+    motif_length = meanrange(args.motif, args.dispersion)
+    motif_template = generate_modif_template(motif_length, alphabet, args.max_variants_position)
+    sys.stderr.write(f"Cluster {n_cluster:2} motif template: {motif_notation(motif_template)}\n")
+    
+    total_length  = meanrange(args.random * 2, args.dispersion) + motif_length
+    prefix_length = meanrange(args.random, args.dispersion//2)
+    suffix_length = total_length - motif_length - prefix_length
+    
+    cliff_made = False
+    for n_seq in range(args.sequences):
+        line_number +=1
+        activity = random.gauss(activity_average, activity_dispersion)
+        
+        motif  = generate_motif(motif_template, alphabet)
+        prefix = generate_random(prefix_length, alphabet)
+        suffix = generate_random(suffix_length, alphabet)
+        seq = prefix + motif + suffix
+
+        is_cliff = random.random() <= args.cliff_probability
+        if is_cliff:
+            # Making activity cliff
+            cliff_motif = make_cliff(motif_template, alphabet, motif)
+            cliff_seq = prefix + cliff_motif + suffix
+            # Recalculating activity
+            cliff_disp = activity_dispersion * args.cliff_strength * (0.5 + random.random())
+            activity = activity_average - cliff_disp
+            cliff_activity = activity_average + cliff_disp
+            
+            sys.stderr.write(f"Cliff for sequence #{line_number:4}, cluster {n_cluster} \n")
+            sys.stderr.write(f"{activity_average}\t{motif}\t{activity}\n")
+            sys.stderr.write(f"{activity_average}\t{cliff_motif}\t{cliff_activity}\n")
+            print(f"{n_cluster}\tc{n_cluster}_seq{line_number}\t{cliff_seq}\t{cliff_activity:5.2f}\t{is_cliff}")
+            line_number +=1
+        print(f"{n_cluster}\tc{n_cluster}_seq{line_number}\t{seq}\t{activity:5.2f}\t{is_cliff}")
+            

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

@@ -3,43 +3,54 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {_package} from '../package';
+import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
 import {delay} from '@datagrok-libraries/utils/src/test';
-import {step} from './utils';
+import {handleError} from './utils';
 
 const dataFn = 'data/sample_FASTA_DNA.csv';
 
-export async function demoBio01UI(funcPath: string) {
+export async function demoBio01UI() {
   let view: DG.TableView;
   let df: DG.DataFrame;
 
   try {
-    await step(`Loading DNA notation 'fasta'.`, async () => {
-      df = await _package.files.readCsv(dataFn);
-      view = grok.shell.addTableView(df);
-      view.path = view.basePath = funcPath;
-    })();
-
-    await step('Sequence similarity search.', async () => {
-      const simViewer = await df.plot.fromType('Sequence Similarity Search') as DG.Viewer;
-      view.dockManager.dock(simViewer, DG.DOCK_TYPE.RIGHT, null, 'Similarity search', 0.35);
-    })();
-
-    await step('Sequence diversity search.', async () => {
-      const divViewer = await df.plot.fromType('Sequence Diversity Search') as DG.Viewer;
-      view.dockManager.dock(divViewer, DG.DOCK_TYPE.DOWN, null, 'Diversity search', 0.27);
-    })();
-
-    await step('Current row 3.', async () => {
-      df.currentRowIdx = 3;
-    })();
-
-    await step('Current row  7', async () => {
-      df.currentRowIdx = 7;
-    });
+    const demoScript = new DemoScript('Demo', 'Sequence similarity / diversity search');
+    await demoScript
+      .step(`Loading DNA notation 'fasta'`, async () => {
+        df = await _package.files.readCsv(dataFn);
+        view = grok.shell.addTableView(df);
+      }, {
+        description: `Load dataset with macromolecules of 'fasta' notation, 'DNA' alphabet.`,
+        delay: 1600
+      })
+      .step('Sequence similarity search', async () => {
+        const simViewer = await df.plot.fromType('Sequence Similarity Search') as DG.Viewer;
+        view.dockManager.dock(simViewer, DG.DOCK_TYPE.RIGHT, null, 'Similarity search', 0.35);
+      }, {
+        description: `Add 'Sequence Similarity Search' viewer.`,
+        delay: 1600
+      })
+      .step('Sequence diversity search', async () => {
+        const divViewer = await df.plot.fromType('Sequence Diversity Search') as DG.Viewer;
+        view.dockManager.dock(divViewer, DG.DOCK_TYPE.DOWN, null, 'Diversity search', 0.27);
+      }, {
+        description: `Add 'Sequence Deversity Search' viewer.`,
+        delay: 1600
+      })
+      .step('Set current row 3', 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 () => {
+        df.currentRowIdx = 7;
+      }, {
+        description: 'Changing current row to another.',
+        delay: 1600,
+      })
+      .start();
   } catch (err: any) {
-    if (err instanceof Error)
-      _package.logger.error(err.message, undefined, err.stack);
-    else
-      _package.logger.error(err.toString());
+    handleError(err);
   }
 }

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

@@ -8,12 +8,13 @@ import * as lev from 'fastest-levenshtein';
 import {DistanceMatrix} from '@datagrok-libraries/bio/src/trees/distance-matrix';
 import {getTreeHelper, ITreeHelper} from '@datagrok-libraries/bio/src/trees/tree-helper';
 import {getDendrogramService, IDendrogramService} from '@datagrok-libraries/bio/src/trees/dendrogram';
-import {demoSequenceSpace, step} from './utils';
+import {demoSequenceSpace, handleError} from './utils';
+import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
 
 const dataFn = 'data/sample_FASTA_DNA.csv';
 const seqColName = 'sequence';
 
-export async function demoBio01aUI(funcPath: string) {
+export async function demoBio01aUI() {
   let treeHelper: ITreeHelper;
   let dendrogramSvc: IDendrogramService;
   let view: DG.TableView;
@@ -25,44 +26,54 @@ export async function demoBio01aUI(funcPath: string) {
   const embedCols: { [colName: string]: DG.Column<number> } = {};
 
   try {
-    await step(`Loading DNA notation 'fasta'.`, async () => {
-      [df, treeHelper, dendrogramSvc] = await Promise.all([
-        _package.files.readCsv(dataFn),
-        getTreeHelper(),
-        getDendrogramService()
-      ]);
-      view = grok.shell.addTableView(df);
-      view.grid.props.rowHeight = 22;
-      view.path = view.basePath = funcPath;
-    })();
-
-    await step('Building sequence space.', async () => {
-      spViewer = await demoSequenceSpace(view, df, seqColName, method);
-    })();
-
-    await step('Hierarchical clustering.', async () => {
-      const seqCol: DG.Column<string> = df.getCol(seqColName);
-      const seqList = seqCol.toList();
-      const distance: DistanceMatrix = DistanceMatrix.calc(seqList, (aSeq: string, bSeq: string) => {
-        const levDistance = lev.distance(aSeq, bSeq);
-        return levDistance / ((aSeq.length + bSeq.length) / 2);
-      });
-      const treeRoot = await treeHelper.hierarchicalClusteringByDistance(distance, 'ward');
-      dendrogramSvc.injectTreeForGrid(view.grid, treeRoot, undefined, 150, undefined);
-    })();
-
-    await step('Selection.', async () => {
-      df.selection.init((idx: number) => [15].includes(idx));
-    })();
-
-    await step('Select a bunch of sequences.', async () => {
-      df.selection.init((idx: number) => [21, 9, 58].includes(idx));
-      df.currentRowIdx = 27;
-    })();
+    const demoScript = new DemoScript('Demo', 'Exploring sequence space');
+    await demoScript
+      .step(`Loading DNA notation 'fasta'`, async () => {
+        [df, treeHelper, dendrogramSvc] = await Promise.all([
+          _package.files.readCsv(dataFn),
+          getTreeHelper(),
+          getDendrogramService()
+        ]);
+        view = grok.shell.addTableView(df);
+        view.grid.props.rowHeight = 22;
+      }, {
+        description: `Load dataset with macromolecules of 'fasta' notation, 'DNA' alphabet.`,
+        delay: 1600,
+      })
+      .step('Building 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 () => {
+        const seqCol: DG.Column<string> = df.getCol(seqColName);
+        const seqList = seqCol.toList();
+        const distance: DistanceMatrix = DistanceMatrix.calc(seqList, (aSeq: string, bSeq: string) => {
+          const levDistance = lev.distance(aSeq, bSeq);
+          return levDistance / ((aSeq.length + bSeq.length) / 2);
+        });
+        const treeRoot = await treeHelper.hierarchicalClusteringByDistance(distance, 'ward');
+        dendrogramSvc.injectTreeForGrid(view.grid, treeRoot, undefined, 150, undefined);
+      }, {
+        description: `Perform hierarchical clustering to reveal relationships between sequences.`,
+        delay: 1600,
+      })
+      .step('Selection', async () => {
+        df.selection.init((idx: number) => [15].includes(idx));
+      }, {
+        description: `Handling selection of data frame row reflecting on linked viewers.`,
+        delay: 1600,
+      })
+      .step('Select a bunch of sequences', async () => {
+        df.selection.init((idx: number) => [21, 9, 58].includes(idx));
+        df.currentRowIdx = 27;
+      }, {
+        description: 'Selecting a group of rows from a data frame to show their similarity and proximity to each other on a viewer..',
+        delay: 1600,
+      })
+      .start();
   } catch (err: any) {
-    if (err instanceof Error)
-      _package.logger.error(err.message, undefined, err.stack);
-    else
-      _package.logger.error(err.toString());
+    handleError(err);
   }
 }

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

@@ -10,11 +10,12 @@ import * as lev from 'fastest-levenshtein';
 import {DistanceMatrix} from '@datagrok-libraries/bio/src/trees/distance-matrix';
 import {getTreeHelper, ITreeHelper} from '@datagrok-libraries/bio/src/trees/tree-helper';
 import {getDendrogramService, IDendrogramService} from '@datagrok-libraries/bio/src/trees/dendrogram';
-import {step} from './utils';
+import {handleError} from './utils';
+import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
 
 const dataFn = 'samples/sample_FASTA.csv';
 
-export async function demoBio01bUI(funcPath: string) {
+export async function demoBio01bUI() {
   let treeHelper: ITreeHelper;
   let dendrogramSvc: IDendrogramService;
   let view: DG.TableView;
@@ -25,70 +26,78 @@ export async function demoBio01bUI(funcPath: string) {
   const idRows: { [id: number]: number } = {};
 
   try {
-    await step('Loading DNA notation \'fasta\'.', async () => {
-      [df, treeHelper, dendrogramSvc] = await Promise.all([
-        _package.files.readCsv(dataFn),
-        getTreeHelper(),
-        getDendrogramService()
-      ]);
+    const demoScript = new DemoScript('Demo', '');
+    await demoScript
+      .step(`Loading DNA notation \'fasta\'`, async () => {
+        [df, treeHelper, dendrogramSvc] = await Promise.all([
+          _package.files.readCsv(dataFn),
+          getTreeHelper(),
+          getDendrogramService()
+        ]);
 
-      view = grok.shell.addTableView(df);
-      view.path = view.basePath = funcPath;
-      view.grid.props.rowHeight = 22;
-      const uniProtKbGCol = view.grid.columns.byName('UniProtKB')!;
-      uniProtKbGCol.width = 75;
-      const lengthGCol = view.grid.columns.byName('Length')!;
-      lengthGCol.width = 0;
-    })();
+        view = grok.shell.addTableView(df);
+        view.grid.props.rowHeight = 22;
+        const uniProtKbGCol = view.grid.columns.byName('UniProtKB')!;
+        uniProtKbGCol.width = 75;
+        const lengthGCol = view.grid.columns.byName('Length')!;
+        lengthGCol.width = 0;
+      }, {
+        description: 'Load dataset with macromolecules of \'fasta\' notation, \'DNA\' alphabet.',
+        delay: 1600,
+      })
+      .step('Analyze for activity cliffs', async () => {
+        activityCliffsViewer = (await activityCliffs(
+          df, df.getCol('Sequence'), df.getCol('Activity'),
+          80, method)) as DG.ScatterPlotViewer;
+        view.dockManager.dock(activityCliffsViewer, DG.DOCK_TYPE.RIGHT, null, 'Activity Cliffs', 0.35);
 
-    await step('Analyze for activity cliffs.', async () => {
-      activityCliffsViewer = (await activityCliffs(
-        df, df.getCol('Sequence'), df.getCol('Activity'),
-        80, method)) as DG.ScatterPlotViewer;
-      view.dockManager.dock(activityCliffsViewer, DG.DOCK_TYPE.RIGHT, null, 'Activity Cliffs', 0.35);
+        // Show grid viewer with the cliffs
+        const cliffsLink: HTMLButtonElement = $(activityCliffsViewer.root)
+          .find('button.scatter_plot_link,cliffs_grid').get()[0] as HTMLButtonElement;
+        cliffsLink.click();
+      }, {
+        description: 'Reveal similar sequences with a cliff of activity.',
+        delay: 1600
+      })
+      .step('Hierarchical clustering', async () => {
+        const seqCol: DG.Column<string> = df.getCol('sequence');
+        const seqList = seqCol.toList();
+        const distance: DistanceMatrix = DistanceMatrix.calc(seqList, (aSeq: string, bSeq: string) => {
+          const levDistance = lev.distance(aSeq, bSeq);
+          return levDistance / ((aSeq.length + bSeq.length) / 2);
+        });
+        const treeRoot = await treeHelper.hierarchicalClusteringByDistance(distance, 'ward');
+        dendrogramSvc.injectTreeForGrid(view.grid, treeRoot, undefined, 150, undefined);
 
-      // Show grid viewer with the cliffs
-      const cliffsLink: HTMLButtonElement = $(activityCliffsViewer.root)
-        .find('button.scatter_plot_link,cliffs_grid').get()[0] as HTMLButtonElement;
-      cliffsLink.click();
-    })();
+        // adjust for visual
+        const activityGCol = view.grid.columns.byName('Activity')!;
+        activityGCol.scrollIntoView();
+      }, {
+        description: 'Perform hierarchical clustering to reveal relationships between sequences.',
+        delay: 1600
+      })
+      .step('Browse the cliff', async () => {
+        //cliffsDfGrid.dataFrame.currentRowIdx = -1; // reset
+        const cliffsDfGrid: DG.Grid = activityCliffsViewer.dataFrame.temp[acTEMPS.cliffsDfGrid];
+        //cliffsDfGrid.dataFrame.selection.init((i) => i == currentCliffIdx);
+        cliffsDfGrid.dataFrame.currentRowIdx = 0;
+        //cliffsDfGrid.dataFrame.selection.set(currentCliffIdx, true, true);
 
-    await step('Hierarchical clustering.', async () => {
-      const seqCol: DG.Column<string> = df.getCol('sequence');
-      const seqList = seqCol.toList();
-      const distance: DistanceMatrix = DistanceMatrix.calc(seqList, (aSeq: string, bSeq: string) => {
-        const levDistance = lev.distance(aSeq, bSeq);
-        return levDistance / ((aSeq.length + bSeq.length) / 2);
-      });
-      const treeRoot = await treeHelper.hierarchicalClusteringByDistance(distance, 'ward');
-      dendrogramSvc.injectTreeForGrid(view.grid, treeRoot, undefined, 150, undefined);
-
-      // adjust for visual
-      const activityGCol = view.grid.columns.byName('Activity')!;
-      activityGCol.scrollIntoView();
-    })();
-
-    await step('Browse the cliff.', async () => {
-      //cliffsDfGrid.dataFrame.currentRowIdx = -1; // reset
-      const cliffsDfGrid: DG.Grid = activityCliffsViewer.dataFrame.temp[acTEMPS.cliffsDfGrid];
-      //cliffsDfGrid.dataFrame.selection.init((i) => i == currentCliffIdx);
-      cliffsDfGrid.dataFrame.currentRowIdx = 0;
-      //cliffsDfGrid.dataFrame.selection.set(currentCliffIdx, true, true);
-
-      // /* workaround to select rows of the cliff */
-      // const entryCol: DG.Column = df.getCol('Entry');
-      // df.selection.init((rowIdx) => ['UPI00000BFE1D', 'UPI00000BFE17'].includes(entryCol.get(rowIdx)));
-      //
-      // const selectionIdxList: Int32Array = df.selection.getSelectedIndexes();
-      // if (selectionIdxList.length > 0) {
-      //   df.currentRowIdx = selectionIdxList[0];
-      //   view.grid.scrollToCell('UniProtKB', view.grid.tableRowToGrid(selectionIdxList[0]));
-      // }
-    })();
+        // /* workaround to select rows of the cliff */
+        // const entryCol: DG.Column = df.getCol('Entry');
+        // df.selection.init((rowIdx) => ['UPI00000BFE1D', 'UPI00000BFE17'].includes(entryCol.get(rowIdx)));
+        //
+        // const selectionIdxList: Int32Array = df.selection.getSelectedIndexes();
+        // if (selectionIdxList.length > 0) {
+        //   df.currentRowIdx = selectionIdxList[0];
+        //   view.grid.scrollToCell('UniProtKB', view.grid.tableRowToGrid(selectionIdxList[0]));
+        // }
+      }, {
+        description: 'Zoom in to explore selected activity cliff details.',
+        delay: 1600
+      })
+      .start();
   } catch (err: any) {
-    if (err instanceof Error)
-      _package.logger.error(err.message, undefined, err.stack);
-    else
-      _package.logger.error(err.toString());
+    handleError(err);
   }
 }

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

@@ -3,15 +3,16 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {_package, sequenceSpaceTopMenu} from '../package';
-import {step} from './utils';
+import {handleError} from './utils';
 
 import {IWebLogoViewer} from '@datagrok-libraries/bio/src/viewers/web-logo';
 import {pepseaMethods, runPepsea} from '../utils/pepsea';
 import {StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
+import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
 
 const helmFn: string = 'samples/sample_HELM.csv';
 
-export async function demoBio05UI(funcPath: string): Promise<void> {
+export async function demoBio05UI(): Promise<void> {
   let view: DG.TableView;
   let df: DG.DataFrame;
   let helmCol: DG.Column<string>;
@@ -23,38 +24,46 @@ export async function demoBio05UI(funcPath: string): Promise<void> {
   const msaHelmColName: string = 'msa(HELM)';
 
   try {
-    await step(`Loading peptides notation 'HELM'.`, async () => {
-      view = grok.shell.addTableView(df = await _package.files.readCsv(helmFn));
-      view.path = view.basePath = funcPath;
-    })();
-
-    await step('MSA on non-natural aminoacids with PepSeA.', async () => {
-      helmCol = df.getCol(helmColName);
-      const method: string = pepseaMethods[0];
-      const gapOpen: number = 1.53;
-      const gapExtend: number = 0;
-      msaHelmCol = await runPepsea(helmCol, msaHelmColName, method, gapOpen, gapExtend, undefined);
-      df.columns.add(msaHelmCol);
-      await grok.data.detectSemanticTypes(df);
-    })();
-
-    await step('Composition analysis on MSA results', async () => {
-      wlViewer = await df.plot.fromType('WebLogo', {
-        sequenceColumnName: msaHelmColName
-      }) as DG.Viewer & IWebLogoViewer;
-      view.dockManager.dock(wlViewer, DG.DOCK_TYPE.DOWN, null, 'Composition analysis', 0.2);
-    })();
-
-    await step('Building sequence space.', async () => {
-      const method: string = 'UMAP';
-      ssViewer = (await sequenceSpaceTopMenu(df, msaHelmCol,
-        'UMAP', StringMetricsNames.Levenshtein, true)) as DG.ScatterPlotViewer;
-      view.dockManager.dock(ssViewer, DG.DOCK_TYPE.RIGHT, null, 'Sequence Space', 0.35);
-    })();
+    const demoScript = new DemoScript('Demo', 'MSA and composition analysis on Helm data.');
+    await demoScript
+      .step(`Loading peptides notation 'HELM'`, async () => {
+        view = grok.shell.addTableView(df = await _package.files.readCsv(helmFn));
+      }, {
+        description: 'Load dataset with macromolecules of \'Helm\' notation.',
+        delay: 1600,
+      })
+      .step('MSA on non-natural aminoacids with PepSeA', async () => {
+        helmCol = df.getCol(helmColName);
+        const method: string = pepseaMethods[0];
+        const gapOpen: number = 1.53;
+        const gapExtend: number = 0;
+        msaHelmCol = await runPepsea(helmCol, msaHelmColName, method, gapOpen, gapExtend, undefined);
+        df.columns.add(msaHelmCol);
+        await grok.data.detectSemanticTypes(df);
+      }, {
+        description: 'Multiple sequence alignment (MSA) performed with PepSeA tool operating on non-natural aminoacids as well.',
+        delay: 1600,
+      })
+      .step('Composition analysis on MSA results', async () => {
+        wlViewer = await df.plot.fromType('WebLogo', {
+          sequenceColumnName: msaHelmColName
+        }) as DG.Viewer & IWebLogoViewer;
+        view.dockManager.dock(wlViewer, DG.DOCK_TYPE.DOWN, null, 'Composition analysis', 0.2);
+      }, {
+        description: 'Composition analysis allows to reveal functional features of sequences like motifs, or variable loops.',
+        delay: 1600,
+      })
+      .step('Building sequence space', async () => {
+        const method: string = 'UMAP';
+        ssViewer = (await sequenceSpaceTopMenu(df, msaHelmCol,
+          'UMAP', StringMetricsNames.Levenshtein, true)) as DG.ScatterPlotViewer;
+        view.dockManager.dock(ssViewer, DG.DOCK_TYPE.RIGHT, null, 'Sequence Space', 0.35);
+      }, {
+        description: 'Reduce sequence space dimensionality to display on 2D representation.',
+        delay: 1600
+      })
+      .start();
   } catch (err: any) {
-    if (err instanceof Error)
-      _package.logger.error(err.message, undefined, err.stack);
-    else
-      _package.logger.error(err.toString());
+    handleError(err);
   }
 }

package/src/demo/utils.ts

@@ -7,19 +7,6 @@ import {reduceDimensinalityWithNormalization} from '@datagrok-libraries/ml/src/s
 import {StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
 import {delay} from '@datagrok-libraries/utils/src/test';
 
-export function step(message: string, action: () => Promise<void>, delayMs: number = 1600): () => Promise<void> {
-  return async function() {
-    grok.shell.info(message);
-    const pi = DG.TaskBarProgressIndicator.create(message);
-    try {
-      await action();
-    } finally {
-      pi.close();
-      await delay(delayMs);
-    }
-  };
-}
-
 enum EMBED_COL_NAMES {
   X = 'Embed_X',
   Y = 'Embed_Y'
@@ -93,3 +80,10 @@ export async function demoSequenceSpace(
   view.dockManager.dock(resSpaceViewer!, DG.DOCK_TYPE.RIGHT, null, 'Sequence Space', 0.35);
   return resSpaceViewer;
 }
+
+export function handleError(err: any): void {
+  const errMsg: string = err instanceof Error ? err.message : err.toString();
+  const stack: string | undefined = err instanceof Error ? err.stack : undefined;
+  grok.shell.error(errMsg);
+  _package.logger.error(err.message, undefined, stack);
+}