@datagrok/peptides 0.8.5 → 0.8.9

package/src/peptides.ts

@@ -1,21 +1,165 @@
 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';
-
-/**
- * Peptides controller class.
- *
- * @export
- * @class Peptides
- */
-export class Peptides {
-  private static _model = model;
-
-  static async recalculate() {
-    await Peptides._model.updateDefault();
+import {PeptidesModel} from './model';
+import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
+import {SARViewer, SARViewerVertical} from './viewers/sar-viewer';
+import {SubstViewer} from './viewers/subst-viewer';
+import {ChemPalette} from './utils/chem-palette';
+import {Observable} from 'rxjs';
+
+type viewerTypes = SARViewer | SARViewerVertical | SubstViewer;
+export class PeptidesController {
+  private static _controllerName: string = 'peptidesController';
+  private helpUrl = '/help/domains/bio/peptides.md';
+  private _dataFrame: DG.DataFrame;
+  private _model: PeptidesModel;
+
+  private constructor(dataFrame: DG.DataFrame) {
+    this._dataFrame = dataFrame;
+    this._model = PeptidesModel.getOrInit(this._dataFrame);
+    // this.getOrInitModel(this._dataFrame);
+  }
+
+  static getInstance(dataFrame: DG.DataFrame): PeptidesController {
+    dataFrame.temp[PeptidesController.controllerName] ??= new PeptidesController(dataFrame);
+    return dataFrame.temp[PeptidesController.controllerName];
+  }
+
+  static get controllerName() {
+    return PeptidesController._controllerName;
+  }
+
+  // getOrInitModel(): PeptidesModel {
+  //   this._model ??= PeptidesModel.getOrInit(this._dataFrame);
+  //   return this._model;
+  // }
+
+  get onStatsDataFrameChanged(): Observable<DG.DataFrame> {
+    return this._model.onStatsDataFrameChanged;
+  }
+
+  get onSARGridChanged(): Observable<DG.Grid> {
+    return this._model.onSARGridChanged;
+  }
+
+  get onSARVGridChanged(): Observable<DG.Grid> {
+    return this._model.onSARVGridChanged;
+  }
+
+  get onGroupMappingChanged(): Observable<StringDictionary> {
+    return this._model.onGroupMappingChanged;
+  }
+
+  get onSubstFlagChanged(): Observable<boolean> {
+    return this._model.onSubstFlagChanged;
+  }
+
+  async updateDefault() {
+    await this._model.updateDefault();
+  }
+
+  async updateData(
+    dataFrame: DG.DataFrame | null, activityCol: string | null, activityScaling: string | null,
+    sourceGrid: DG.Grid | null, twoColorMode: boolean | null, initialBitset: DG.BitSet | null,
+    grouping: boolean | null) {
+    await this._model.updateData(
+      dataFrame, activityCol, activityScaling, sourceGrid, twoColorMode, initialBitset, grouping);
+  }
+
+  static async scaleActivity(
+    activityScaling: string, activityColumn: string, activityColumnScaled: string, df: DG.DataFrame,
+  ): Promise<[DG.DataFrame, string]> {
+    // const df = sourceGrid.dataFrame!;
+    const tempDf = df.clone(null, [activityColumn]);
+
+    let formula = '${' + activityColumn + '}';
+    let newColName = activityColumn;
+    switch (activityScaling) {
+    case 'none':
+      break;
+    case 'lg':
+      formula = `Log10(${formula})`;
+      newColName = `Log10(${newColName})`;
+      break;
+    case '-lg':
+      formula = `-1*Log10(${formula})`;
+      newColName = `-Log10(${newColName})`;
+      break;
+    default:
+      throw new Error(`ScalingError: method \`${activityScaling}\` is not available.`);
+    }
+
+    await (tempDf.columns as DG.ColumnList).addNewCalculated(activityColumnScaled, formula);
+
+    return [tempDf, newColName];
+  }
+
+  static splitAlignedPeptides(peptideColumn: DG.Column, filter: boolean = true): [DG.DataFrame, number[]] {
+    const splitPeptidesArray: string[][] = [];
+    let currentSplitPeptide: string[];
+    let modeMonomerCount = 0;
+    let currentLength;
+    const colLength = peptideColumn.length;
+
+    // splitting data
+    const monomerLengths: {[index: string]: number} = {};
+    for (let i = 0; i < colLength; i++) {
+      currentSplitPeptide = peptideColumn.get(i).split('-').map((value: string) => value ? value : '-');
+      splitPeptidesArray.push(currentSplitPeptide);
+      currentLength = currentSplitPeptide.length;
+      monomerLengths[currentLength + ''] =
+        monomerLengths[currentLength + ''] ? monomerLengths[currentLength + ''] + 1 : 1;
+    }
+    //@ts-ignore: what I do here is converting string to number the most effective way I could find. parseInt is slow
+    modeMonomerCount = 1 * Object.keys(monomerLengths).reduce((a, b) => monomerLengths[a] > monomerLengths[b] ? a : b);
+
+    // making sure all of the sequences are of the same size
+    // and marking invalid sequences
+    let nTerminal: string;
+    const invalidIndexes: number[] = [];
+    let splitColumns: string[][] = Array.from({length: modeMonomerCount}, (_) => []);
+    modeMonomerCount--; // minus N-terminal
+    for (let i = 0; i < colLength; i++) {
+      currentSplitPeptide = splitPeptidesArray[i];
+      nTerminal = currentSplitPeptide.pop()!; // it is guaranteed that there will be at least one element
+      currentLength = currentSplitPeptide.length;
+      if (currentLength !== modeMonomerCount)
+        invalidIndexes.push(i);
+
+      for (let j = 0; j < modeMonomerCount; j++)
+        splitColumns[j].push(j < currentLength ? currentSplitPeptide[j] : '-');
+
+      splitColumns[modeMonomerCount].push(nTerminal);
+    }
+    modeMonomerCount--; // minus C-terminal
+
+    //create column names list
+    const columnNames = Array.from({length: modeMonomerCount}, (_, index) => `${index + 1 < 10 ? 0 : ''}${index + 1 }`);
+    columnNames.splice(0, 0, 'N-terminal');
+    columnNames.push('C-terminal');
+
+    // filter out the columns with the same values
+    if (filter) {
+      splitColumns = splitColumns.filter((positionArray, index) => {
+        const isRetained = new Set(positionArray).size > 1;
+        if (!isRetained)
+          columnNames.splice(index, 1);
+
+        return isRetained;
+      });
+    }
+
+    return [
+      DG.DataFrame.fromColumns(splitColumns.map((positionArray, index) => {
+        return DG.Column.fromList('string', columnNames[index], positionArray);
+      })),
+      invalidIndexes,
+    ];
+  }
+
+  static getChemPalette() {
+    return ChemPalette;
   }
 
   /**
@@ -24,18 +168,22 @@ export class Peptides {
    * @param {DG.Grid} tableGrid Working talbe grid.
    * @param {DG.TableView} view Working view.
    * @param {DG.DataFrame} currentDf Working table.
-   * @param {{[key: string]: string}} options SAR viewer options
+   * @param {StringDictionary} options SAR viewer options
    * @param {DG.Column} col Aligned sequences column.
-   * @param {string} activityColumnChoice Activity column name.
    * @memberof Peptides
    */
   async init(
-    tableGrid: DG.Grid,
-    view: DG.TableView,
-    currentDf: DG.DataFrame,
-    options: {[key: string]: string},
-    col: DG.Column,
-  ) {
+    tableGrid: DG.Grid, view: DG.TableView, options: StringDictionary, col: DG.Column,
+    originalDfColumns: string[]) {
+    function adjustCellSize(grid: DG.Grid) {
+      const colNum = grid.columns.length;
+      for (let i = 0; i < colNum; ++i) {
+        const iCol = grid.columns.byIndex(i)!;
+        iCol.width = isNaN(parseInt(iCol.name)) ? 50 : 40;
+      }
+      grid.props.rowHeight = 20;
+    }
+
     for (let i = 0; i < tableGrid.columns.length; i++) {
       const aarCol = tableGrid.columns.byIndex(i);
       if (aarCol &&
@@ -47,120 +195,87 @@ 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']},
-    // );
-    // const substNode = view.dockManager.dock(substViewer, DG.DOCK_TYPE.RIGHT, null, 'Substitution Analysis');
+    const originalDfName = this._dataFrame.name;
+    const dockManager = view.dockManager;
 
-    // const layout1 = view.saveLayout();
-    // view.dockManager.close(substNode);
+    const sarViewer = await this._dataFrame.plot.fromType('peptide-sar-viewer', options) as SARViewer;
+    sarViewer.helpUrl = this.helpUrl;
 
-    const sarViewer = view.addViewer('peptide-sar-viewer', options);
-    const sarNode = view.dockManager.dock(sarViewer, DG.DOCK_TYPE.DOWN, null, 'SAR Viewer');
+    const sarViewerVertical = await this._dataFrame.plot.fromType('peptide-sar-viewer-vertical') as SARViewerVertical;
+    sarViewerVertical.helpUrl = this.helpUrl;
 
-    const sarViewerVertical = view.addViewer('peptide-sar-viewer-vertical');
-    const sarVNode = view.dockManager.dock(sarViewerVertical, DG.DOCK_TYPE.RIGHT, sarNode, 'SAR Vertical Viewer');
+    const sarViewersGroup: viewerTypes[] = [sarViewer, sarViewerVertical];
 
     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);
-
-    const layout2 = view.saveLayout();
-
-    const nodeList = [sarNode, sarVNode, psNode];
-
-    const StackedBarchartProm = currentDf.plot.fromType('StackedBarChartAA');
-    addViewerToHeader(tableGrid, StackedBarchartProm);
+      this._dataFrame, col, 't-SNE', 'Levenshtein', 100, view, `${options['activityColumnName']}Scaled`);
+    dockManager.dock(peptideSpaceViewer, DG.DOCK_TYPE.RIGHT, null, 'Peptide Space viewer');
+
+    let nodeList = dockViewers(sarViewersGroup, DG.DOCK_TYPE.RIGHT, dockManager, DG.DOCK_TYPE.DOWN);
+
+    const substViewer = await this._dataFrame.plot.fromType(
+      'substitution-analysis-viewer', {'activityColumnName': `${options['activityColumnName']}Scaled`}) as SubstViewer;
+    const substViewersGroup = [substViewer];
+
     tableGrid.props.allowEdit = false;
+    adjustCellSize(tableGrid);
 
-    const hideIcon = ui.iconFA('window-close', () => { //undo?, times?
+    const hideIcon = ui.iconFA('window-close', () => {
       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);
+      const cols = (this._dataFrame.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);
-      currentDf.filter.setAll(true);
+      this._dataFrame.selection.setAll(false);
+      this._dataFrame.filter.setAll(true);
 
       tableGrid.setOptions({'colHeaderHeight': 20});
       tableGrid.columns.setVisible(originalDfColumns);
       tableGrid.props.allowEdit = true;
-      currentDf.name = originalDfName;
+      this._dataFrame.name = originalDfName;
 
       view.setRibbonPanels(ribbonPanels);
     }, 'Close viewers and restore dataframe');
 
     let isSA = false;
-    //TODO: fix layouts
-    // const switchViewers = ui.iconFA('toggle-on', () => {
-    //   if (isSA) {
-    //     view.loadLayout(layout1);
-    //     $(switchViewers).removeClass('fa-toggle-off');
-    //     $(switchViewers).addClass('fa-toggle-on');
-    //   } else {
-    //     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);
-        const sarNode = view.dockManager.dock(sarViewer, DG.DOCK_TYPE.DOWN, null, 'SAR Viewer');
-
-        const sarViewerVertical = view.addViewer('peptide-sar-viewer-vertical');
-        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']},
-        );
-        nodeList.push(view.dockManager.dock(substViewer, DG.DOCK_TYPE.RIGHT, null, 'Substitution Analysis'));
-        $(switchViewers).removeClass('fa-toggle-on');
-        $(switchViewers).addClass('fa-toggle-off');
-      }
+    const switchViewers = ui.iconFA('toggle-on', () => {
+      $(switchViewers).toggleClass('fa-toggle-off').toggleClass('fa-toggle-on');
+      nodeList?.forEach((node) => {
+        view.dockManager.close(node);
+        node.container.destroy();
+      });
+      const getCurrentViewerGroup = () => isSA ? substViewersGroup : sarViewersGroup;
+      getCurrentViewerGroup().forEach((v) => v.removeFromView());
       isSA = !isSA;
-    });
+      nodeList = dockViewers(getCurrentViewerGroup(), DG.DOCK_TYPE.LEFT, dockManager, DG.DOCK_TYPE.DOWN);
+    }, 'Toggle viewer group');
 
     const ribbonPanels = view.getRibbonPanels();
     view.setRibbonPanels([[hideIcon, switchViewers]]);
-    // view.setRibbonPanels([[hideIcon]]);
   }
 }
+
+function dockViewers(
+  viewerList: viewerTypes[], attachDirection: DG.DockType, dockManager: DG.DockManager,
+  initialAttachDirection?: DG.DockType): DG.DockNode[] | null {
+  const viewerListLength = viewerList.length;
+  if (viewerListLength === 0)
+    return null;
+
+  let currentViewer = viewerList[0];
+  const nodeList = [dockManager.dock(currentViewer, initialAttachDirection, null, currentViewer.name ?? '')];
+  const ratio = 1 / viewerListLength;
+
+  for (let i = 1; i < viewerListLength; i++) {
+    currentViewer = viewerList[i];
+    nodeList.push(dockManager.dock(currentViewer, attachDirection, nodeList[i - 1], currentViewer.name ?? '', ratio));
+  }
+  return nodeList;
+}

package/src/tests/msa-tests.ts

@@ -0,0 +1,27 @@
+import {category, test} from '@datagrok-libraries/utils/src/test';
+import {
+  _testMSAIsCorrect,
+  _testTableIsNotEmpty,
+} from './utils';
+import {aligned1} from './test-data';
+
+import * as DG from 'datagrok-api/dg';
+//import * as grok from 'datagrok-api/grok';
+
+export const _package = new DG.Package();
+
+let table: DG.DataFrame;
+
+category('peptides', async () => {
+  //table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');
+  table = DG.DataFrame.fromCsv(aligned1);
+  const alignedSequencesColumn = table.getCol('AlignedSequence');
+
+  test('MSA.test_table.is_not_empty', async () => {
+    _testTableIsNotEmpty(table);
+  });
+
+  test('MSA.is_correct', async () => {
+    _testMSAIsCorrect(alignedSequencesColumn);
+  });
+});

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

@@ -1,21 +1,53 @@
-import {category, test} from '@datagrok-libraries/utils/src/test';
+import {/*before, after, */category, test} from '@datagrok-libraries/utils/src/test';
 import {
   _testViewerIsDrawing,
   _testDimensionalityReducer,
   _testPeptideSimilaritySpaceViewer,
+  _testTableIsNotEmpty,
 } from './utils';
 import {DimensionalityReducer} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {cleanAlignedSequencesColumn} from '../utils/peptide-similarity-space';
+import {aligned1} from './test-data';
 
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+import {StringMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 
+export const _package = new DG.Package();
+
+let table: DG.DataFrame;
+let view: DG.TableView;
+
+//const table = await grok.data.loadTable(`${_package.webRoot}files/aligned.csv`);
+//'/home/www/data/dev/packages/data/peptides/aligned.csv');
+//console.log(table);
+//const table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');
 
 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;
+  /*before(async () => {
+    console.log(['before']);
+    // const text = await _package.files.readAsText('aligned.csv');
+    // console.log([text]);
+    // table = DG.DataFrame.fromCsv(text);
+
+    // const path = `${_package.webRoot}files/aligned.csv`;
+    // console.log([path]);
+    // table = await grok.data.loadTable(path);
+    // console.log([table]);
+
+    table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');
+    view = grok.shell.addTableView(table);
+  });*/
 
-  test('PeptideSimilaritySpaceWidget.is_drawing', async () => {
+  //table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');
+  table = DG.DataFrame.fromCsv(aligned1);
+  view = grok.shell.addTableView(table);
+
+  test('peptide_space.test_table.is_not_empty', async () => {
+    _testTableIsNotEmpty(table);
+  });
+
+  test('peptide_space.PeptideSimilaritySpaceWidget.is_drawing', async () => {
     await _testViewerIsDrawing(table, view);
   });
 
@@ -23,18 +55,23 @@ category('peptides', async () => {
   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 measure of DimensionalityReducer.availableMetricsByType('String')) {
+      test(`peptide_space.DimensinalityReducer.${method}.${measure}.is_numeric`, async () => {
+        await _testDimensionalityReducer(columnData, method as StringMetrics, measure);
       });
     }
   }
 
   for (const method of DimensionalityReducer.availableMethods) {
-    for (const measure of DimensionalityReducer.availableMetrics) {
-      test(`peptides.PeptideSimilaritySpaceViewer.${method}.${measure}.is_proper`, async () => {
+    for (const measure of DimensionalityReducer.availableMetricsByType('String')) {
+      test(`peptide_space.PeptideSimilaritySpaceViewer.${method}.${measure}.is_proper`, async () => {
         await _testPeptideSimilaritySpaceViewer(table, alignedSequencesColumn, method, measure, 100);//, view);
       });
     }
   }
+
+  /*after(async () => {
+    view.close();
+    grok.shell.closeTable(table!);
+  });*/
 });

package/src/tests/peptides-tests.ts

@@ -1,25 +1,26 @@
-import {after, before, category, expect, 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 * as ui from "datagrok-api/ui";
-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";
-
-export let _package = new DG.Package();
+import {after, before, category, test} from '@datagrok-libraries/utils/src/test';
+import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
+// import {splitAlignedPeptides} from '../utils/split-aligned';
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import {PeptidesController} 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 options: StringDictionary;
   let peptidesGrid: DG.Grid;
   let asCol: DG.Column;
   let pepView: DG.TableView;
 
   before(async () => {
-    // peptidesDf = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned.csv'));
+    // 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
@@ -45,24 +46,28 @@ category('peptides', async () => {
       'activityColumnName': 'IC50',
       'scaling': '-lg',
     };
-    peptidesGrid = peptidesDf.plot.grid();
     asCol = peptidesDf.getCol('AlignedSequence');
     pepView = grok.shell.addTableView(peptidesDf);
+    peptidesGrid = pepView.grid;
   });
 
   test('utils.split-sequence', async () => {
-    splitAlignedPeptides(peptidesDf.getCol('AlignedSequence'));
+    PeptidesController.splitAlignedPeptides(peptidesDf.getCol('AlignedSequence'));
   });
 
   test('describe', async () => {
     await describe(
-      peptidesDf, options['activityColumnName'], options['scaling'],  peptidesGrid, true,
+      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('Peptides-controller', async () => {
+    const peptides = PeptidesController.getInstance(peptidesDf);
+    peptides.init(peptidesGrid, pepView, options, asCol, peptidesDf.columns.names());
+  });
+
+  test('panel.peptides', async () => {
+    await P.peptidesPanel(asCol);
   });
 
   test('widgets.analyze-peptides', async () => {
@@ -77,8 +82,40 @@ category('peptides', 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);
-  })
+  });
 });