@datagrok/bio 2.4.17 → 2.4.19

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.4.17",
+  "version": "2.4.19",
   "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",
@@ -16,8 +16,8 @@
     "@biowasm/aioli": "^3.1.0",
     "@datagrok-libraries/bio": "^5.29.3",
     "@datagrok-libraries/chem-meta": "^1.0.1",
-    "@datagrok-libraries/ml": "^6.3.22",
-    "@datagrok-libraries/tutorials": "^1.2.1",
+    "@datagrok-libraries/ml": "^6.3.23",
+    "@datagrok-libraries/tutorials": "^1.3.1",
     "@datagrok-libraries/utils": "^2.1.3",
     "cash-dom": "^8.0.0",
     "css-loader": "^6.7.3",

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

@@ -16,9 +16,11 @@ export async function demoBio01UI() {
   let df: DG.DataFrame;
 
   try {
-    const demoScript = new DemoScript('Demo', 'Sequence similarity / diversity search');
+    const demoScript = new DemoScript(
+      'Similarity, Diversity',
+      'Sequence similarity tracking and evaluation dataset diversity');
     await demoScript
-      .step(`Loading DNA notation 'fasta'`, async () => {
+      .step(`Load DNA sequences`, async () => {
         grok.shell.windows.showContextPanel = false;
         grok.shell.windows.showProperties = false;
 
@@ -30,9 +32,9 @@ export async function demoBio01UI() {
         // TODO: Fix column width
       }, {
         description: `Load dataset with macromolecules of 'fasta' notation, 'DNA' alphabet.`,
-        delay: 1200
+        delay: 2000
       })
-      .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',
@@ -40,9 +42,9 @@ export async function demoBio01UI() {
         view.dockManager.dock(simViewer, DG.DOCK_TYPE.RIGHT, null, 'Similarity search', 0.35);
       }, {
         description: `Add 'Sequence Similarity Search' viewer.`,
-        delay: 1600
+        delay: 2000
       })
-      .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'
@@ -50,19 +52,19 @@ export async function demoBio01UI() {
         view.dockManager.dock(divViewer, DG.DOCK_TYPE.DOWN, null, 'Diversity search', 0.27);
       }, {
         description: `Add 'Sequence Deversity Search' viewer.`,
-        delay: 1600
+        delay: 2000
       })
-      .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,
+        delay: 2000,
       })
-      .step('Set current row 7', async () => {
+      .step('One more sequence for similarity search', async () => {
         df.currentRowIdx = 7;
       }, {
-        description: 'Changing current row to another.',
-        delay: 1600,
+        description: 'Just one more sequence to search similar ones.',
+        delay: 2000,
       })
       .start();
   } catch (err: any) {

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

@@ -26,9 +26,11 @@ export async function demoBio01aUI() {
   const embedCols: { [colName: string]: DG.Column<number> } = {};
 
   try {
-    const demoScript = new DemoScript('Demo', 'Exploring sequence space');
+    const demoScript = new DemoScript(
+      'Demo',
+      'Exploring sequence space of Macromolecules, comparison with hierarchical clustering results');
     await demoScript
-      .step(`Loading DNA notation 'fasta'`, async () => {
+      .step(`Load DNA sequences`, async () => {
         [df, treeHelper, dendrogramSvc] = await Promise.all([
           _package.files.readCsv(dataFn),
           getTreeHelper(),
@@ -41,15 +43,15 @@ export async function demoBio01aUI() {
         grok.shell.windows.showProperties = false;
       }, {
         description: `Load dataset with macromolecules of 'fasta' notation, 'DNA' alphabet.`,
-        delay: 1600,
+        delay: 2000,
       })
-      .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
+        delay: 2000
       })
-      .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) => {
@@ -60,20 +62,20 @@ export async function demoBio01aUI() {
         dendrogramSvc.injectTreeForGrid(view.grid, treeRoot, undefined, 150, undefined);
       }, {
         description: `Perform hierarchical clustering to reveal relationships between sequences.`,
-        delay: 1600,
+        delay: 2000,
       })
-      .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.`,
-        delay: 1600,
+        delay: 2000,
       })
       .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,
+        delay: 2000,
       })
       .start();
   } catch (err: any) {

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

@@ -13,22 +13,25 @@ import {getDendrogramService, IDendrogramService} from '@datagrok-libraries/bio/
 import {handleError} from './utils';
 import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
 
-const dataFn = 'samples/sample_FASTA.csv';
+const dataFn: string = 'samples/sample_FASTA.csv';
 
 export async function demoBio01bUI() {
   let treeHelper: ITreeHelper;
   let dendrogramSvc: IDendrogramService;
-  let view: DG.TableView;
+
   let df: DG.DataFrame;
+  let view: DG.TableView;
   let activityCliffsViewer: DG.ScatterPlotViewer;
 
   const method: string = 'UMAP';
   const idRows: { [id: number]: number } = {};
 
   try {
-    const demoScript = new DemoScript('Demo', '');
+    const demoScript = new DemoScript(
+      'Activity Cliffs',
+      'Activity Cliffs analysis on Macromolecules data');
     await demoScript
-      .step(`Loading DNA notation \'fasta\'`, async () => {
+      .step(`Load DNA sequences`, async () => {
         grok.shell.windows.showContextPanel = false;
         grok.shell.windows.showProperties = false;
 
@@ -46,9 +49,9 @@ export async function demoBio01bUI() {
         lengthGCol.width = 0;
       }, {
         description: 'Load dataset with macromolecules of \'fasta\' notation, \'DNA\' alphabet.',
-        delay: 1600,
+        delay: 2000,
       })
-      .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;
@@ -60,9 +63,9 @@ export async function demoBio01bUI() {
         cliffsLink.click();
       }, {
         description: 'Reveal similar sequences with a cliff of activity.',
-        delay: 1600
+        delay: 2000
       })
-      .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) => {
@@ -77,7 +80,7 @@ export async function demoBio01bUI() {
         activityGCol.scrollIntoView();
       }, {
         description: 'Perform hierarchical clustering to reveal relationships between sequences.',
-        delay: 1600
+        delay: 2000
       })
       .step('Browse the cliff', async () => {
         //cliffsDfGrid.dataFrame.currentRowIdx = -1; // reset
@@ -97,7 +100,7 @@ export async function demoBio01bUI() {
         // }
       }, {
         description: 'Zoom in to explore selected activity cliff details.',
-        delay: 1600
+        delay: 2000
       })
       .start();
   } catch (err: any) {

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

@@ -0,0 +1,66 @@
+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';
+import {delay} from '@datagrok-libraries/utils/src/test';
+
+const dataFn: string = 'samples/sample_FASTA.csv';
+
+export async function demoBio03UI(): Promise<void> {
+  let df: DG.DataFrame;
+  let view: DG.TableView;
+  let dlg: DG.Dialog;
+
+  try {
+    await new DemoScript(
+      'Atomic Level',
+      'Atomic level structure of Macromolecules'
+    )
+      .step(`Loading Macromolecules notation 'Helm'`, async () => {
+        grok.shell.windows.showContextPanel = false;
+        grok.shell.windows.showProperties = false;
+
+        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: 2000,
+      })
+      .step('To atomic level', async () => {
+        const seqCol = df.getCol('Sequence');
+        await toAtomicLevel(df, seqCol);
+      }, {
+        description: 'Get atomic level structures of Macromolecules.',
+        delay: 2000,
+      })
+      .step('Sketcher', async () => {
+        const molColName: string = 'molfile(Sequence)';
+        df.currentCell = df.cell(1, molColName);
+        const mol: string = df.currentCell.value;
+
+        const sketcher = new DG.chem.Sketcher(DG.chem.SKETCHER_MODE.INPLACE);
+        sketcher.setMolFile(mol);
+
+        dlg = ui.dialog()
+          .add(sketcher)
+          .show();
+        await delay(3000);
+        dlg.close();
+      }, {
+        description: 'Display atomic level structure within a sketcher.',
+        delay: 2000,
+      })
+      .start();
+  } catch (err: any) {
+    handleError(err);
+  }
+}

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

@@ -24,18 +24,20 @@ export async function demoBio05UI(): Promise<void> {
   const msaHelmColName: string = 'msa(HELM)';
 
   try {
-    const demoScript = new DemoScript('Demo', 'MSA and composition analysis on Helm data.');
+    const demoScript = new DemoScript(
+      'Helm, MSA, Sequence Space',
+      '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;
         grok.shell.windows.showProperties = false;
       }, {
         description: 'Load dataset with macromolecules of \'Helm\' notation.',
-        delay: 1600,
+        delay: 2000,
       })
-      .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;
@@ -45,18 +47,18 @@ export async function demoBio05UI(): Promise<void> {
         await grok.data.detectSemanticTypes(df);
       }, {
         description: 'Multiple sequence alignment (MSA) performed with PepSeA tool operating on non-natural aminoacids as well.',
-        delay: 1600,
+        delay: 2000,
       })
-      .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;
         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
+        delay: 2000
       })
-      .step('Composition analysis on MSA results', async () => {
+      .step('Analyse sequence composition', async () => {
         wlViewer = await df.plot.fromType('WebLogo', {
           sequenceColumnName: msaHelmColName,
           maxHeight: 50,
@@ -64,7 +66,7 @@ export async function demoBio05UI(): Promise<void> {
         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,
+        delay: 2000,
       })
       .start();
   } catch (err: any) {

package/src/package-test.ts

@@ -22,6 +22,7 @@ import './tests/substructure-filters-tests';
 import './tests/pepsea-tests';
 import './tests/viewers';
 import './tests/units-handler-tests';
+import './tests/mm-distance-tests';
 
 // Tests hanging github CI
 import './tests/activity-cliffs-tests';

package/src/package.ts

@@ -9,7 +9,7 @@ import {
 } from './utils/cell-renderer';
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
 import {SequenceAlignment} from './seq_align';
-import {getEmbeddingColsNames, sequenceSpaceByFingerprints, getSequenceSpace} from './analysis/sequence-space';
+import {getEmbeddingColsNames, sequenceSpaceByFingerprints} from './analysis/sequence-space';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {
   createLinesGrid,
@@ -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.');
         });
       });
@@ -287,23 +290,19 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
     'separator': macroMolecule.getTag(bioTAGS.separator),
     'alphabet': macroMolecule.getTag(bioTAGS.alphabet),
   };
-  const uh = new UnitsHandler(macroMolecule);
-  let columnDistanceMetric = 'Tanimoto';
-  if (uh.isFasta())
-    columnDistanceMetric = uh.getDistanceFunctionName();
   const sp = await getActivityCliffs(
     df,
     macroMolecule,
     null,
     axesNames,
-    columnDistanceMetric,
+    'Activity cliffs',
     activities,
     similarity,
     'Tanimoto',
     methodName,
     DG.SEMTYPE.MACROMOLECULE,
     tags,
-    getSequenceSpace,
+    sequenceSpaceByFingerprints,
     getChemSimilaritiesMatrix,
     createTooltipElement,
     createPropPanelElement,
@@ -354,7 +353,7 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
     embedAxesNames: embedColsNames,
     options: options
   };
-  const sequenceSpaceRes = await getSequenceSpace(chemSpaceParams);
+  const sequenceSpaceRes = await sequenceSpaceByFingerprints(chemSpaceParams);
   const embeddings = sequenceSpaceRes.coordinates;
   for (const col of embeddings) {
     const listValues = col.toList();
@@ -672,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();
@@ -681,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();
@@ -690,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/mm-distance-tests.ts

@@ -0,0 +1,138 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {category, expect, test} from '@datagrok-libraries/utils/src/test';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {MmDistanceFunctionsNames, mmDistanceFunctions}
+  from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
+
+category('Distance', async () => {
+  const scoringMatrix = [
+    [1, 0, 0, 0],
+    [0, 1, 0, 0],
+    [0, 0, 1, 0],
+    [0, 0, 0, 1],
+  ];
+
+  const alphabetIndexes = {'F': 0, 'W': 1, 'R': 2, 'Y': 3};
+
+  const prot1 = 'FWRWY';
+  const prot2 = 'FWRWW';
+
+  const prot3 = 'FWY';
+  const prot4 = 'FWRWY';
+
+  const prot5 = 'FWY';
+  const prot6 = 'FWRRRRY';
+
+  const protTable = `seq
+      FWRWYVKHP
+      YNRWYVKHP
+      MWRSWYCKHP`;
+
+  const DNATable = `seq
+      ATAACG
+      ATCGA
+      ATCGA`;
+
+  const MSATable = `seq
+      ATAAC
+      ATCGA
+      ATCGA`;
+  test('protein-distance-function', async () => {
+    const uh = await _initMacromoleculeColumn(protTable);
+    const distFunc = uh.getDistanceFunctionName();
+    expect(distFunc, MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH);
+  });
+
+  test('DNA-distance-function', async () => {
+    const uh = await _initMacromoleculeColumn(DNATable);
+    const distFunc = uh.getDistanceFunctionName();
+    expect(distFunc, MmDistanceFunctionsNames.LEVENSHTEIN);
+  });
+
+  test('MSA-distance-function', async () => {
+    const uh = await _initMacromoleculeColumn(MSATable);
+    const distFunc = uh.getDistanceFunctionName();
+    expect(distFunc, MmDistanceFunctionsNames.HAMMING);
+  });
+
+  test('levenstein-sub', async () => {
+    const df = mmDistanceFunctions[MmDistanceFunctionsNames.LEVENSHTEIN]();
+    _testDistance(prot1, prot2, df, 1);
+  });
+  test('levenstein-del', async () => {
+    const df = mmDistanceFunctions[MmDistanceFunctionsNames.LEVENSHTEIN]();
+    _testDistance(prot3, prot4, df, 2);
+  });
+
+  test('hamming', async () => {
+    const df = mmDistanceFunctions[MmDistanceFunctionsNames.HAMMING]();
+    _testDistance(prot3, prot4, df, 3);
+  });
+
+  // Note that here the result is actually an inverted value of alignment score, which is coorelated with distance
+  // tests using default BLOSUM62 matrix are in agreement with the results of the online tool
+  test('needleman-blosum62', async () => {
+    const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH]();
+    _testDistance(prot1, prot2, df, -35);
+  });
+
+  test('needleman-blosum62-del', async () => {
+    const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH]();
+    _testDistance(prot3, prot4, df, -14);
+  });
+
+  test('needleman-custom-sub', async () => {
+    const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH](
+      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 1}
+    );
+    _testDistance(prot1, prot2, df, -4);
+  });
+
+  test('needleman-custom-del', async () => {
+    const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH](
+      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 1}
+    );
+    _testDistance(prot3, prot4, df, -1);
+  });
+
+  test('needleman-custom-zero-extend', async () => {
+    const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH](
+      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 0}
+    );
+    _testDistance(prot5, prot6, df, -2);
+  });
+
+  test('needleman-custom-half-extend', async () => {
+    const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH](
+      {scoringMatrix, alphabetIndexes, gapOpen: 2, gapExtend: 1}
+    );
+    _testDistance(prot5, prot6, df, 2);
+  });
+
+  test('needleman-custom-same-extend', async () => {
+    const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH](
+      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 1}
+    );
+    _testDistance(prot5, prot6, df, 1);
+  });
+});
+
+async function _initMacromoleculeColumn(csv: string): Promise<UnitsHandler> {
+  const srcDf: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+  const seqCol = srcDf.col('seq')!;
+  const semType: string = await grok.functions
+    .call('Bio:detectMacromolecule', {col: seqCol}) as unknown as string;
+  if (semType)
+    seqCol.semType = semType;
+  await grok.data.detectSemanticTypes(srcDf);
+  const uh = new UnitsHandler(seqCol);
+  return uh;
+}
+
+function _testDistance(seq1: string, seq2: string, df: (a: string, b: string) => number, expected: number) {
+  const d = df(seq1, seq2);
+  expect(d, expected);
+}

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);
   });
 });