@datagrok/peptides 0.6.1 → 0.8.6

package/src/monomer-library.ts

@@ -0,0 +1,187 @@
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+/** HELM associated sdf libraries with monomer processing*/
+export class MonomerLibrary {
+  private monomerFields: string[] = ['molecule', 'MonomerType', 'MonomerNaturalAnalogCode', 'MonomerName', 'MonomerCode', 'MonomerCaps', 'BranchMonomer'];
+  private library: {
+    [name: string]: {
+      mol: string,
+      type: string,
+      analogueCode: string,
+      linkages: { [link: string]: { atomNumber: number, type: string } }
+    }
+  } = {};
+  private monomers: string[] = [];
+
+  constructor(sdf: string) {
+    //sdf = sdf.replaceAll('\n\[', '\[');
+    const sdfReader = new SDFReader();
+    const data = sdfReader.get_colls(sdf);
+    this.monomerFields.forEach((f) => {
+      if (!(f in data))
+        throw `Monomer library was not compiled: ${f} field is absent in provided file`;
+
+      if (data[f].length != data.molecule.length)
+        throw `Monomer library was not compiled: ${f} field is not presented for each monomer`;
+    });
+
+    for (let i = 0; i < data.molecule.length; i++) {
+      const linkData = this.getLinkData(data.molecule[i], data.MonomerCaps[i], data.MonomerName[i]);
+      const entry = {
+        mol: data.molecule[i],
+        type: 'Peptide',
+        code: data.MonomerCode[i],
+        analogueCode: data.MonomerNaturalAnalogCode[i],
+        linkages: linkData,
+      };
+
+      const name = data.MonomerCode[i] !== '.' ? data.MonomerCode[i] : data.MonomerName[i];
+      this.library[name] = entry;
+      this.monomers.push(data.MonomerName[i]);
+    }
+  }
+
+  /** getting full monomer information from monomer library*/
+  public getMonomerEntry(name: string) {
+    if (!this.monomers.includes(name))
+      throw `Monomer library do not contain ${name} monomer`;
+
+
+    return this.library[name];
+  }
+
+  /** getting mol as string for monomer*/
+  public getMonomerMol(name: string) {
+    if (!this.monomers.includes(name))
+      throw `Monomer library do not contain ${name} monomer`;
+
+
+    const entry = this.library[name];
+    let monomerMol = entry.mol.replace(/M  RGP  .+\n/, '');
+
+    //order matters
+    const links = Object.keys(entry.linkages);
+    for (let i = 0; i < links.length; i++)
+      monomerMol = monomerMol.replace('R#', entry.linkages[links[i]].type + ' ');
+
+
+    return monomerMol;
+  }
+
+  /** getting the list of the minomers available in library*/
+  get monomerNames() {
+    return this.monomers;
+  }
+
+  private getLinkData(mol: string, caps: string, name: string) {
+    const rawData = mol.match(/M  RGP  .+/);
+    if (rawData === null)
+      throw `Monomer library was not compiled: ${name} entry has no RGP`;
+
+
+    const types: { [code: string]: string } = {};
+    caps.split('\n')?.forEach((e) => {
+      types[e.match(/\d+/)![0]] = e.match(/(?<=\])\w+/)![0];
+    });
+
+    const data = rawData![0].replace('M  RGP  ', '').split(/\s+/);
+    const res: { [link: string]: { atomNumber: number, type: string } } = {};
+    for (let i = 0; i < parseInt(data[0]); i++) {
+      const code = parseInt(data[2 * i + 2]);
+      let type = '';
+      switch (code) {
+      case 1:
+        type = 'N-terminal';
+        break;
+      case 2:
+        type = 'C-terminal';
+        break;
+      case 3:
+        type = 'branch';
+        break;
+      default:
+        break;
+      }
+      res[type] = {atomNumber: parseInt(data[2 * i + 1]), type: types[code]};
+    }
+
+    return res;
+  }
+}
+
+//TODO: merge with Chem version
+class SDFReader {
+  dataColls: { [_: string]: any };
+
+  constructor() {
+    this.dataColls = {'molecule': []};
+  }
+
+  get_colls(content: string) {
+    this.read(content);
+    return this.dataColls;
+  }
+
+  read(content: string) {
+    content = content.replaceAll('\r', ''); //equalize old and new sdf standards
+    let startIndex = content.indexOf('$$$$', 0);
+    this.parse(content, 0, startIndex, (name: string, val: any) => { // TODO: type
+      this.dataColls[name] = [];
+      this.dataColls[name].push(val);
+    });
+    startIndex += 5;
+    while (startIndex > -1 && startIndex < content.length)
+      startIndex = this.readNext(content, startIndex);
+  }
+
+  readNext(content: string, startIndex: number) {
+    const nextStartIndex = content.indexOf('$$$$', startIndex);
+    if (nextStartIndex === -1)
+      return -1;
+    else {
+      this.parse(content, startIndex, nextStartIndex,
+        (name: string, val: number) => this.dataColls[name].push(val));
+    }
+
+    if (nextStartIndex > -1)
+      return nextStartIndex + 5;
+
+
+    return nextStartIndex;
+  }
+
+  parse(content: string, start: number, end: number, handler: any) {
+    const molEnd = +content.indexOf('M  END\n', start) + 7;
+    let localEnd = start;
+    this.dataColls['molecule'].push(content.substr(start, molEnd - start));
+
+    start = molEnd;
+    while (localEnd < end) {
+      start = content.indexOf('> <', localEnd);
+      if (start === -1)
+        return;
+
+
+      start += 3;
+      localEnd = content.indexOf('>\n', start);
+      if (localEnd === -1)
+        return;
+
+
+      const propertyName = content.substring(start, localEnd);
+      start = localEnd + 2;
+
+      localEnd = content.indexOf('\n', start);
+      if (localEnd === -1)
+        localEnd = end;
+      else if (content[localEnd + 1] != '\n')
+        localEnd = content.indexOf('\n', ++localEnd);
+      ;
+
+      handler(propertyName, content.substring(start, localEnd));
+      localEnd += 2;
+    }
+  }
+}

package/src/package-test.ts

@@ -0,0 +1,18 @@
+import * as DG from 'datagrok-api/dg';
+
+import {runTests} from '@datagrok-libraries/utils/src/test';
+
+import './tests/peptide-space-test';
+import './tests/peptides-tests';
+
+export const _package = new DG.Package();
+
+//name: test
+//input: string category {optional: true}
+//input: string test {optional: true}
+//output: dataframe result
+//top-menu: Tools | Dev | JS API Tests
+export async function test(category: string, test: string): Promise<DG.DataFrame> {
+  const data = await runTests({category, test});
+  return DG.DataFrame.fromObjects(data)!;
+}

package/src/package.ts

@@ -14,9 +14,9 @@ import {analyzePeptidesWidget} from './widgets/analyze-peptides';
 import {PeptideSimilaritySpaceWidget} from './utils/peptide-similarity-space';
 import {manualAlignmentWidget} from './widgets/manual-alignment';
 import {SARViewer, SARViewerVertical} from './viewers/sar-viewer';
-import {peptideMoleculeWidget} from './widgets/peptide-molecule';
-import {SpiralPlot} from './viewers/spiral-plot';
+import {peptideMoleculeWidget, getMolecule} from './widgets/peptide-molecule';
 import {SubstViewer} from './viewers/subst-viewer';
+import {runKalign} from './utils/multiple-sequence-alignment';
 
 export const _package = new DG.Package();
 let tableGrid: DG.Grid;
@@ -38,9 +38,9 @@ async function main(chosenFile: string) {
   pi.close();
 }
 
-//name: Peptides App
+//name: Peptides
 //tags: app
-export function Peptides() {
+export async function Peptides() {
   const wikiLink = ui.link('wiki', 'https://github.com/datagrok-ai/public/blob/master/help/domains/bio/peptides.md');
   const textLink = ui.inlineText(['For more details, see our ', wikiLink, '.']);
 
@@ -73,8 +73,8 @@ export function Peptides() {
     appDescription,
     ui.info([textLink]),
     ui.divH([
-      ui.button('Open peptide sequences demonstration set', () => main('aligned.csv'), ''),
-      ui.button('Open complex case demo', () => main('aligned_2.csv'), ''),
+      ui.button('Simple demo', () => main('aligned.csv'), ''),
+      ui.button('Complex demo', () => main('aligned_2.csv'), ''),
     ]),
   ]);
 }
@@ -84,9 +84,9 @@ export function Peptides() {
 //input: column col {semType: alignedSequence}
 //output: widget result
 export async function peptidesPanel(col: DG.Column): Promise<DG.Widget> {
-  if (col.getTag('isAnalysisApplicable') === 'false') {
+  if (col.getTag('isAnalysisApplicable') === 'false')
     return new DG.Widget(ui.divText('Analysis is not applicable'));
-  }
+
   view = (grok.shell.v as DG.TableView);
   tableGrid = view.grid;
   currentDf = col.dataFrame;
@@ -136,6 +136,15 @@ export async function peptideMolecule(peptide: string): Promise<DG.Widget> {
   return await peptideMoleculeWidget(peptide);
 }
 
+//name: Peptide Molecule
+//tags: panel, widgets
+//input: string aar {semType: aminoAcids}
+//output: widget result
+export async function peptideMolecule2(aar: string): Promise<DG.Widget> {
+  const peptide = alignedSequenceCol.get(currentDf.currentRowIdx);
+  return await peptideMolecule(peptide);
+}
+
 //name: StackedBarChartAA
 //tags: viewer
 //output: viewer result
@@ -171,6 +180,7 @@ export function logov() {
 //input: string monomer {semType: aminoAcids}
 //output: widget result
 export function manualAlignment(monomer: string) {
+  //TODO: recalculate Molfile and Molecule panels on sequence update
   return manualAlignmentWidget(alignedSequenceCol, currentDf);
 }
 
@@ -183,15 +193,31 @@ export async function peptideSpacePanel(col: DG.Column): Promise<DG.Widget> {
   return await widget.draw();
 }
 
-//name: Spiral Plot
-////input: dataframe table
-////input: column activity
-//tags: viewer, panel
-//output: viewer result
-export async function spiralPlot(): Promise<DG.Viewer> {//(table: DG.DataFrame, activity: DG.Column) {
-// Read as dataframe
-  const table = await grok.data.files.openTable('Demo:TestJobs:Files:DemoFiles/bio/peptides.csv');
-  const activity = await table.columns.addNewCalculated('-log10(Activity)', '0-Log10(${Activity})');
-  view = grok.shell.addTableView(table);
-  return view.addViewer(SpiralPlot.fromTable(table, {valuesColumnName: activity.name}));
+//name: Molfile
+//tags: panel, widgets
+//input: string peptide { semType: alignedSequence }
+//output: widget result
+export async function peptideMolfile(peptide: string): Promise<DG.Widget> {
+  const smiles = getMolecule(peptide);
+  return await grok.functions.call('Chem:molfile', {'smiles': smiles});
+}
+
+//name: Molfile
+//tags: panel, widgets
+//input: string aar { semType: aminoAcids }
+//output: widget result
+export async function peptideMolfile2(aar: string): Promise<DG.Widget> {
+  const peptide = alignedSequenceCol.get(currentDf.currentRowIdx);
+  return await peptideMolfile(peptide);
+}
+
+//name: Multiple sequence alignment
+//tags: panel
+//input: column col {semType: alignedSequence}
+//output: dataframe result
+export async function multipleSequenceAlignment(col: DG.Column): Promise<DG.DataFrame> {
+  const msaCol = await runKalign(col, true);
+  const table = col.dataFrame;
+  table.columns.add(msaCol);
+  return table;
 }

package/src/peptides.ts

@@ -2,6 +2,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {createPeptideSimilaritySpaceViewer} from './utils/peptide-similarity-space';
 import {addViewerToHeader} from './viewers/stacked-barchart-viewer';
+import {model} from './model';
 // import $ from 'cash-dom';
 
 /**
@@ -11,6 +12,12 @@ import {addViewerToHeader} from './viewers/stacked-barchart-viewer';
  * @class Peptides
  */
 export class Peptides {
+  private static _model = model;
+
+  static async recalculate() {
+    await Peptides._model.updateDefault();
+  }
+
   /**
    * Class initializer
    *
@@ -28,7 +35,6 @@ export class Peptides {
     currentDf: DG.DataFrame,
     options: {[key: string]: string},
     col: DG.Column,
-    activityColumnChoice: string,
   ) {
     for (let i = 0; i < tableGrid.columns.length; i++) {
       const aarCol = tableGrid.columns.byIndex(i);
@@ -41,18 +47,26 @@ export class Peptides {
       }
     }
 
+    const initialFiter = currentDf.filter.clone();
     const originalDfColumns = (currentDf.columns as DG.ColumnList).names();
     const originalDfName = currentDf.name;
 
-    const substViewer = view.addViewer(
-      'substitution-analysis-viewer', {'activityColumnName': options['activityColumnName']},
-    );
-    view.dockManager.dock(substViewer, DG.DOCK_TYPE.RIGHT, null, 'Substitution Analysis');
+    // const substViewer = view.addViewer(
+    //   'substitution-analysis-viewer', {'activityColumnName': options['activityColumnName']},
+    // );
+    // const substNode = view.dockManager.dock(substViewer, DG.DOCK_TYPE.RIGHT, null, 'Substitution Analysis');
+
+    // const layout1 = view.saveLayout();
+    // view.dockManager.close(substNode);
+
+    const helpUrl = '/help/domains/bio/peptides.md';
 
     const sarViewer = view.addViewer('peptide-sar-viewer', options);
+    sarViewer.helpUrl = helpUrl;
     const sarNode = view.dockManager.dock(sarViewer, DG.DOCK_TYPE.DOWN, null, 'SAR Viewer');
 
     const sarViewerVertical = view.addViewer('peptide-sar-viewer-vertical');
+    sarViewerVertical.helpUrl = helpUrl;
     const sarVNode = view.dockManager.dock(sarViewerVertical, DG.DOCK_TYPE.RIGHT, sarNode, 'SAR Vertical Viewer');
 
     const peptideSpaceViewer = await createPeptideSimilaritySpaceViewer(
@@ -62,11 +76,13 @@ export class Peptides {
       'Levenshtein',
       100,
       view,
-      `${activityColumnChoice}Scaled`,
+      `${options['activityColumnChoice']}Scaled`,
     );
     const psNode = view.dockManager.dock(peptideSpaceViewer, DG.DOCK_TYPE.LEFT, sarNode, 'Peptide Space Viewer', 0.3);
-    // const sarDockNodes = [sarNode, sarVNode, psNode];
-    // const sarViewers = [sarViewer, sarViewerVertical, peptideSpaceViewer];
+
+    const layout2 = view.saveLayout();
+
+    const nodeList = [sarNode, sarVNode, psNode];
 
     const StackedBarchartProm = currentDf.plot.fromType('StackedBarChartAA');
     addViewerToHeader(tableGrid, StackedBarchartProm);
@@ -75,17 +91,15 @@ export class Peptides {
     const hideIcon = ui.iconFA('window-close', () => { //undo?, times?
       const viewers = [];
       for (const viewer of view.viewers) {
-        if (viewer.type !== DG.VIEWER.GRID) {
+        if (viewer.type !== DG.VIEWER.GRID)
           viewers.push(viewer);
-        }
       }
       viewers.forEach((v) => v.close());
 
       const cols = (currentDf.columns as DG.ColumnList);
       for (const colName of cols.names()) {
-        if (!originalDfColumns.includes(colName)) {
+        if (!originalDfColumns.includes(colName))
           cols.remove(colName);
-        }
       }
 
       currentDf.selection.setAll(false);
@@ -99,42 +113,59 @@ export class Peptides {
       view.setRibbonPanels(ribbonPanels);
     }, 'Close viewers and restore dataframe');
 
-    // let substViewer: DG.Viewer | null = null;
-    // let substNode: DG.DockNode | null = null;
-    // let isSA = false;
-    // let viewLayout1: DG.ViewLayout | null = null;
-    // let viewLayout2: DG.ViewLayout | null = null;
+    let isSA = false;
+    //TODO: fix layouts
     // const switchViewers = ui.iconFA('toggle-on', () => {
     //   if (isSA) {
-    //     viewLayout2 = view.saveLayout();
-    //     // view.dockManager.close(substNode!);
-    //     substViewer?.close();
-
-    //     view.loadLayout(viewLayout1!);
-
+    //     view.loadLayout(layout1);
     //     $(switchViewers).removeClass('fa-toggle-off');
     //     $(switchViewers).addClass('fa-toggle-on');
     //   } else {
-    //     viewLayout1 = view.saveLayout();
-    //     // sarDockNodes.forEach((node) => view.dockManager.close(node));
-    //     sarViewers.forEach((v) => v.close());
-
-    //     if (viewLayout2 === null) {
-    //       substViewer = view.addViewer(
-    //         'substitution-analysis-viewer', {'activityColumnName': options['activityColumnName']},
-    //       );
-    //       substNode = view.dockManager.dock(substViewer, DG.DOCK_TYPE.DOWN, null, 'Substitution Analysis');
-    //     } else {
-    //       view.loadLayout(viewLayout2);
-    //     }
-
+    //     view.loadLayout(layout2);
     //     $(switchViewers).removeClass('fa-toggle-on');
     //     $(switchViewers).addClass('fa-toggle-off');
     //   }
     //   isSA = !isSA;
     // });
+    const switchViewers = ui.iconFA('toggle-on', async () => {
+      currentDf.filter.copyFrom(initialFiter);
+      currentDf.selection.setAll(false);
+      nodeList.forEach((node) => view.dockManager.close(node));
+      nodeList.length = 0;
+      if (isSA) {
+        const sarViewer = view.addViewer('peptide-sar-viewer', options);
+        sarViewer.helpUrl = helpUrl;
+        const sarNode = view.dockManager.dock(sarViewer, DG.DOCK_TYPE.DOWN, null, 'SAR Viewer');
+
+        const sarViewerVertical = view.addViewer('peptide-sar-viewer-vertical');
+        sarViewerVertical.helpUrl = helpUrl;
+        const sarVNode = view.dockManager.dock(sarViewerVertical, DG.DOCK_TYPE.RIGHT, sarNode, 'SAR Vertical Viewer');
+
+        const peptideSpaceViewer = await createPeptideSimilaritySpaceViewer(
+          currentDf, col, 't-SNE', 'Levenshtein', 100, view, `${options['activityColumnChoice']}Scaled`);
+        const psNode = view.dockManager.dock(
+          peptideSpaceViewer, DG.DOCK_TYPE.LEFT, sarNode, 'Peptide Space Viewer', 0.3);
+
+        nodeList.push(sarNode);
+        nodeList.push(sarVNode);
+        nodeList.push(psNode);
+
+        $(switchViewers).removeClass('fa-toggle-off');
+        $(switchViewers).addClass('fa-toggle-on');
+      } else {
+        const substViewer = view.addViewer(
+          'substitution-analysis-viewer', {'activityColumnName': options['activityColumnName']},
+        );
+        substViewer.helpUrl = helpUrl;
+        nodeList.push(view.dockManager.dock(substViewer, DG.DOCK_TYPE.DOWN, null, 'Substitution Analysis'));
+        $(switchViewers).removeClass('fa-toggle-on');
+        $(switchViewers).addClass('fa-toggle-off');
+      }
+      isSA = !isSA;
+    });
 
     const ribbonPanels = view.getRibbonPanels();
-    view.setRibbonPanels([[hideIcon]]);
+    view.setRibbonPanels([[hideIcon, switchViewers]]);
+    // view.setRibbonPanels([[hideIcon]]);
   }
 }

package/src/semantics.ts

@@ -0,0 +1,5 @@
+export const SEMTYPE = {
+  ALIGNED: 'alignedSequence',
+};
+
+

package/src/styles.css

@@ -35,3 +35,12 @@
   height: 50px;
   overflow: hidden;
 }
+
+#pep-hist-host #center {
+  height: 131px;
+}
+
+#pep-hist-host > #root {
+  height: unset;
+  width: 100%;
+}

package/src/tests/peptide-space-test.ts

@@ -0,0 +1,40 @@
+import {category, test} from '@datagrok-libraries/utils/src/test';
+import {
+  _testViewerIsDrawing,
+  _testDimensionalityReducer,
+  _testPeptideSimilaritySpaceViewer,
+} from './utils';
+import {DimensionalityReducer} from '@datagrok-libraries/ml/src/reduce-dimensionality';
+import {cleanAlignedSequencesColumn} from '../utils/peptide-similarity-space';
+
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+
+category('peptides', async () => {
+  const table = await grok.data.files.openTable('Demo:TestJobs:Files:DemoFiles/bio/peptides.csv');
+  const view = grok.shell.v as DG.TableView;
+
+  test('PeptideSimilaritySpaceWidget.is_drawing', async () => {
+    await _testViewerIsDrawing(table, view);
+  });
+
+  const alignedSequencesColumn = table.getCol('AlignedSequence');
+  const columnData = cleanAlignedSequencesColumn(alignedSequencesColumn);
+
+  for (const method of DimensionalityReducer.availableMethods) {
+    for (const measure of DimensionalityReducer.availableMetrics) {
+      test(`DimensinalityReducer.${method}.${measure}.is_numeric`, async () => {
+        await _testDimensionalityReducer(columnData, method, measure);
+      });
+    }
+  }
+
+  for (const method of DimensionalityReducer.availableMethods) {
+    for (const measure of DimensionalityReducer.availableMetrics) {
+      test(`peptides.PeptideSimilaritySpaceViewer.${method}.${measure}.is_proper`, async () => {
+        await _testPeptideSimilaritySpaceViewer(table, alignedSequencesColumn, method, measure, 100);//, view);
+      });
+    }
+  }
+});

package/src/tests/peptides-tests.ts

@@ -0,0 +1,120 @@
+import {after, before, category, test} from '@datagrok-libraries/utils/src/test';
+import {splitAlignedPeptides} from '../utils/split-aligned';
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import {Peptides} from '../peptides';
+import {describe} from '../describe';
+import {analyzePeptidesWidget} from '../widgets/analyze-peptides';
+import {manualAlignmentWidget} from '../widgets/manual-alignment';
+import {peptideMoleculeWidget} from '../widgets/peptide-molecule';
+import * as P from '../package';
+
+// let _package = new DG.Package();
+
+category('peptides', async () => {
+  let peptidesDf: DG.DataFrame;
+  let options: {[key: string]: string};
+  let peptidesGrid: DG.Grid;
+  let asCol: DG.Column;
+  let pepView: DG.TableView;
+
+  before(async () => {
+    // peptidesDf = DG.DataFrame.fromCsv(await P._package.files.readAsText('aligned.csv'));
+    const csv = `ID,AlignedSequence,IC50
+    1,NH2--A-Q-T-T-Y-K-N-Y-R-R-N-L-L--COOH,4.6411368455908086e-4
+    2,NH2-M-A-N-T-T-Y-K-N-Y-R-N-N-L-L--COOH,0.003327324930165897
+    3,NH2--A-N-T-T-Y-K-C-Y-R-R-N-L-L--COOH,3.0748148478921324e-4
+    4,NH2--A-N-T-T-Y-K-F-Y-R-R-N-L-L--COOH,0.0015532837750281958
+    5,NH2--A-V-T-T-Y-K-N-Y-R-R-N-L-L--COOH,6.549885174778741e-4
+    6,NH2--A-N-T-T-Y-K-N-Y-R-R-N-L-L--COOH,0.00213298315038382
+    7,NH2--A-N-T-T-Y-K-N-Y-R-F-N-L-L--COOH,0.002171297321903189
+    8,NH2--A-N-T-T-Y-K-N-Y-R-R-N-H-L--COOH,0.002060711496394637
+    9,NH2-M-A-N-T-T-Y-K-N-Y-R-R-N-L-L--COOH,0.0016058870359321516
+    10,NH2--A-N-T-T-Y-K-N-Y-R-N-N-L-L--COOH,0.00212911675087592
+    11,NH2--A-N-T-T-Y-K-N-Y-R-R-N-L-L--COOH,0.002736311013579287
+    12,NH2--A-N-T-T-Y-K-N-Y-R-R-N-L-L--COOH,5.673074652436946e-5
+    13,NH2-C-A-N-T-T-Y-K-N-Y-R-R-N-L-L--COOH,0.0032881139376902814
+    14,NH2--A-N-T-T-Y-K-N-Y-R-H-N-L-L--COOH,0.0012828163841736553
+    15,NH2-Y-A-N-T-T-Y-K-N-Y-R-D-N-L-L--COOH,7.186983807098166e-4
+    16,NH2-M-A-N-T-T-Y-K-N-Y-R-N-N-L-L--COOH,0.00659708587488309
+    17,NH2-P-A-N-T-T-Y-K-N-Y-R-G-N-L-L--COOH,3.7620528849324097e-4
+    18,NH2-Y-A-N-T--Y-K-N-Y-R-S-N-L-L--COOH,6.812868474160967e-4
+    19,NH2--A-N-T-T-Y-K-N-Y-R-S-N-L-L--COOH,0.0010148578953195436`;
+    peptidesDf = DG.DataFrame.fromCsv(csv);
+    options = {
+      'activityColumnName': 'IC50',
+      'scaling': '-lg',
+    };
+    asCol = peptidesDf.getCol('AlignedSequence');
+    pepView = grok.shell.addTableView(peptidesDf);
+    peptidesGrid = pepView.grid;
+  });
+
+  test('utils.split-sequence', async () => {
+    splitAlignedPeptides(peptidesDf.getCol('AlignedSequence'));
+  });
+
+  test('describe', async () => {
+    await describe(
+      peptidesDf, options['activityColumnName'], options['scaling'], peptidesGrid, true,
+      DG.BitSet.create(peptidesDf.rowCount, (i) => i % 2 === 0), true);
+  });
+
+  test('Peptides-class', async () => {
+    const peptides = new Peptides();
+    peptides.init(peptidesGrid, pepView, peptidesDf, options, asCol);
+  });
+
+  test('panel.peptides', async () => {
+    await P.peptidesPanel(asCol);
+  });
+
+  test('widgets.analyze-peptides', async () => {
+    await analyzePeptidesWidget(asCol, pepView, peptidesGrid, peptidesDf);
+  });
+
+  test('widgets.manual-alignment', async () => {
+    manualAlignmentWidget(asCol, peptidesDf);
+  });
+
+  test('widgets.peptide-molecule', async () => {
+    await peptideMoleculeWidget('NH2--A-N-T-T-Y-K-N-Y-R-S-N-L-L--COOH');
+  });
+
+  test('widgets.molfile', async () => {
+    await P.peptideMolfile2('');
+  });
+
+  test('renderers.aligned-sequence-cell', async () => {
+    P.alignedSequenceCellRenderer();
+  });
+
+  test('renderers.amino-acids-cell', async () => {
+    P.aminoAcidsCellRenderer();
+  });
+
+  test('viewers.logo-viewer', async () => {
+    P.logov();
+  });
+
+  test('viewers.sar-viewer', async () => {
+    P.sar();
+  });
+
+  test('viewers.sar-vertical-viewer', async () => {
+    P.sarVertical();
+  });
+
+  test('viewers.stacked-barchart-viewer', async () => {
+    P.stackedBarChart();
+  });
+
+  test('viewers.subst-viewer', async () => {
+    P.subst();
+  });
+
+  after(async () => {
+    pepView.close();
+    grok.shell.closeTable(peptidesDf);
+  });
+});