@datagrok/peptides 0.8.13 → 1.0.0

package/src/monomer-library.ts

@@ -1,19 +1,21 @@
+export type MonomerEntry = {
+  mol: string,
+  type: string,
+  analogueCode: string,
+  linkages: { [link: string]: { atomNumber: number, type: string } }
+};
+export type MonomerEntries = {[name: string]: MonomerEntry};
+export type LinkData = { [link: string]: { atomNumber: number, type: string } };
+
 /** HELM associated sdf libraries with monomer processing*/
 export class MonomerLibrary {
-  private static _name = 'monomerLibrary';
+  static libName = '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 library: MonomerEntries = {};
 
   private monomers: string[] = [];
 
@@ -45,16 +47,15 @@ export class MonomerLibrary {
   }
 
   /** getting full monomer information from monomer library*/
-  public getMonomerEntry(name: string) {
+  public getMonomerEntry(name: string): MonomerEntry {
     if (!this.monomers.includes(name))
       throw new Error(`Monomer library do not contain ${name} monomer`);
 
-
     return this.library[name];
   }
 
   /** getting mol as string for monomer*/
-  public getMonomerMol(name: string) {
+  public getMonomerMol(name: string): string {
     if (!this.monomers.includes(name))
       throw new Error(`Monomer library do not contain ${name} monomer`);
 
@@ -64,35 +65,34 @@ export class MonomerLibrary {
 
     //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 + ' ');
+    for (const link of links)
+      monomerMol = monomerMol.replace('R#', entry.linkages[link].type + ' ');
 
 
     return monomerMol;
   }
 
   /** getting the list of the minomers available in library*/
-  get monomerNames() {
+  get monomerNames(): string[] {
     return this.monomers;
   }
 
   static get id(): string {
-    return MonomerLibrary._name;
+    return MonomerLibrary.libName;
   }
 
-  private getLinkData(mol: string, caps: string, name: string) {
+  private getLinkData(mol: string, caps: string, name: string): LinkData {
     const rawData = mol.match(/M  RGP  .+/);
     if (rawData === null)
       throw new Error(`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 } } = {};
+    const data = rawData[0].replace('M  RGP  ', '').split(/\s+/);
+    const res: LinkData = {};
     for (let i = 0; i < parseInt(data[0]); i++) {
       const code = parseInt(data[2 * i + 2]);
       let type = '';
@@ -118,21 +118,21 @@ export class MonomerLibrary {
 
 //TODO: merge with Chem version
 class SDFReader {
-  dataColls: { [_: string]: any };
+  dataColls: { [_: string]: string [] };
 
   constructor() {
     this.dataColls = {'molecule': []};
   }
 
-  getColls(content: string) {
+  getColls(content: string): { [_: string]: string[] } {
     this.read(content);
     return this.dataColls;
   }
 
-  read(content: string) {
+  read(content: string): void {
     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.parse(content, 0, startIndex, (name: string, val: string): void => { // TODO: type
       this.dataColls[name] = [];
       this.dataColls[name].push(val);
     });
@@ -141,13 +141,15 @@ class SDFReader {
       startIndex = this.readNext(content, startIndex);
   }
 
-  readNext(content: string, startIndex: number) {
+  readNext(content: string, startIndex: number): 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));
+        (name: string, val: string): void => {
+          this.dataColls[name].push(val);
+        });
     }
 
     if (nextStartIndex > -1)
@@ -157,10 +159,10 @@ class SDFReader {
     return nextStartIndex;
   }
 
-  parse(content: string, start: number, end: number, handler: any) {
+  parse(content: string, start: number, end: number, handler: (name: string, val: string) => void): void {
     const molEnd = +content.indexOf('M  END\n', start) + 7;
     let localEnd = start;
-    this.dataColls['molecule'].push(content.substr(start, molEnd - start));
+    this.dataColls['molecule'].push(content.substring(start, molEnd));
 
     start = molEnd;
     while (localEnd < end) {
@@ -182,8 +184,7 @@ class SDFReader {
       if (localEnd === -1)
         localEnd = end;
       else if (content[localEnd + 1] != '\n')
-        localEnd = content.indexOf('\n', ++localEnd);
-      ;
+        localEnd = content.indexOf('\n', localEnd + 1);
 
       handler(propertyName, content.substring(start, localEnd));
       localEnd += 2;

package/src/package-test.ts

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

package/src/package.ts

@@ -10,7 +10,6 @@ import {
   AlignedSequenceDifferenceCellRenderer,
   AminoAcidsCellRenderer,
 } from './utils/cell-renderer';
-import {Logo} from './viewers/logo-viewer';
 import {StackedBarChart} from './viewers/stacked-barchart-viewer';
 
 import {analyzePeptidesWidget} from './widgets/analyze-peptides';
@@ -19,24 +18,19 @@ import {manualAlignmentWidget} from './widgets/manual-alignment';
 import {SARViewer, SARViewerVertical} from './viewers/sar-viewer';
 import {peptideMoleculeWidget, getMolecule} from './widgets/peptide-molecule';
 import {runKalign, testMSAEnoughMemory} from './utils/multiple-sequence-alignment';
-import {substitutionsWidget} from './widgets/subst-table';
 import {msaWidget} from './widgets/multiple-sequence-alignment';
-import {getDistributionWidget} from './widgets/distribution';
 import {PeptideSpaceViewer} from './viewers/peptide-space-viewer';
 
 export const _package = new DG.Package();
-let currentGrid: DG.Grid;
 let currentTable: DG.DataFrame;
 let alignedSequenceColumn: DG.Column;
-let currentView: DG.TableView;
 
-async function main(chosenFile: string) {
+async function main(chosenFile: string): Promise<void> {
   const pi = DG.TaskBarProgressIndicator.create('Loading Peptides');
   const path = _package.webRoot + 'files/' + chosenFile;
-  const peptides = (await grok.data.loadTable(path));
+  const peptides = await grok.data.loadTable(path);
   peptides.name = 'Peptides';
   const view = grok.shell.addTableView(peptides);
-  currentGrid = view.grid;
   view.name = 'PeptidesView';
   grok.shell.windows.showProperties = true;
 
@@ -45,7 +39,7 @@ async function main(chosenFile: string) {
 
 //name: Peptides
 //tags: app
-export async function Peptides() {
+export async function Peptides(): Promise<void> {
   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, '.']);
 
@@ -93,8 +87,7 @@ export async function peptidesPanel(col: DG.Column): Promise<DG.Widget> {
   if (!(col.temp['isAnalysisApplicable'] ?? true))
     return new DG.Widget(ui.divText('Analysis is not applicable'));
 
-  [currentView, currentGrid, currentTable, alignedSequenceColumn] =
-    getOrDefine(undefined, undefined, col.dataFrame, col);
+  [currentTable, alignedSequenceColumn] = getOrDefine(col.dataFrame, col);
   return analyzePeptidesWidget(currentTable, alignedSequenceColumn);
 }
 
@@ -137,16 +130,16 @@ export async function stackedBarchartWidget(col: DG.Column): Promise<DG.Widget>
 //input: string peptide {semType: alignedSequence}
 //output: widget result
 export async function peptideMolecule(peptide: string): Promise<DG.Widget> {
-  return peptideMoleculeWidget(peptide);
+  [currentTable, alignedSequenceColumn] = getOrDefine();
+  return peptideMoleculeWidget(peptide, currentTable);
 }
 
 //name: Peptide Molecule
 //tags: panel, widgets
-//input: string aar {semType: aminoAcids}
+//input: string _aar {semType: aminoAcids}
 //output: widget result
-export async function peptideMolecule2(aar: string): Promise<DG.Widget> {
-  [currentView, currentGrid, currentTable, alignedSequenceColumn] =
-    getOrDefine();
+export async function peptideMolecule2(_aar: string): Promise<DG.Widget> {
+  [currentTable, alignedSequenceColumn] = getOrDefine();
   const peptide = alignedSequenceColumn.get(currentTable.currentRowIdx);
   return peptideMolecule(peptide);
 }
@@ -159,35 +152,27 @@ export function stackedBarChart(): DG.JsViewer {
 }
 
 //name: alignedSequenceCellRenderer
-//tags: cellRenderer, cellRenderer-alignedSequence
-//meta-cell-renderer-sem-type: alignedSequence
+//tags: cellRenderer
+//meta.cellType: alignedSequence
 //output: grid_cell_renderer result
-export function alignedSequenceCellRenderer() {
+export function alignedSequenceCellRenderer(): AlignedSequenceCellRenderer {
   return new AlignedSequenceCellRenderer();
 }
 
 //name: aminoAcidsCellRenderer
-//tags: cellRenderer, cellRenderer-aminoAcids
-//meta-cell-renderer-sem-type: aminoAcids
+//tags: cellRenderer
+//meta.cellType: aminoAcids
 //output: grid_cell_renderer result
-export function aminoAcidsCellRenderer() {
+export function aminoAcidsCellRenderer(): AminoAcidsCellRenderer {
   return new AminoAcidsCellRenderer();
 }
 
-//name: peptide-logo-viewer
-//tags: viewer, panel
-//output: viewer result
-export function logov() {
-  return new Logo();
-}
-
 //name: Manual Alignment
 //tags: panel, widgets
-//input: string monomer {semType: aminoAcids}
+//input: string _monomer {semType: aminoAcids}
 //output: widget result
-export function manualAlignment(monomer: string) {
-  [currentView, currentGrid, currentTable, alignedSequenceColumn] =
-    getOrDefine();
+export function manualAlignment(_monomer: string): DG.Widget {
+  [currentTable, alignedSequenceColumn] = getOrDefine();
   //TODO: recalculate Molfile and Molecule panels on sequence update
   return manualAlignmentWidget(alignedSequenceColumn, currentTable);
 }
@@ -197,9 +182,8 @@ export function manualAlignment(monomer: string) {
 //input: column col {semType: alignedSequence}
 //output: widget result
 export async function peptideSpacePanel(col: DG.Column): Promise<DG.Widget> {
-  [currentView, currentGrid, currentTable, alignedSequenceColumn] =
-    getOrDefine(undefined, undefined, col.dataFrame, col);
-  const widget = new PeptideSimilaritySpaceWidget(col, currentView);
+  [currentTable, alignedSequenceColumn] = getOrDefine(col.dataFrame, col);
+  const widget = new PeptideSimilaritySpaceWidget(col, grok.shell.v as DG.TableView);
   return widget.draw();
 }
 
@@ -208,17 +192,17 @@ export async function peptideSpacePanel(col: DG.Column): Promise<DG.Widget> {
 //input: string peptide { semType: alignedSequence }
 //output: widget result
 export async function peptideMolfile(peptide: string): Promise<DG.Widget> {
-  const smiles = getMolecule(peptide);
-  return grok.functions.call('Chem:molfile', {'smiles': smiles});
+  [currentTable, alignedSequenceColumn] = getOrDefine();
+  const smiles = getMolecule(peptide, alignedSequenceColumn.tags[C.TAGS.SEPARATOR]);
+  return grok.functions.call('Chem:molfile', {'smiles': smiles}) as Promise<DG.Widget>;
 }
 
 //name: Molfile
 //tags: panel, widgets
-//input: string aar { semType: aminoAcids }
+//input: string _aar { semType: aminoAcids }
 //output: widget result
-export async function peptideMolfile2(aar: string): Promise<DG.Widget> {
-  [currentView, currentGrid, currentTable, alignedSequenceColumn] =
-    getOrDefine();
+export async function peptideMolfile2(_aar: string): Promise<DG.Widget> {
+  [currentTable, alignedSequenceColumn] = getOrDefine();
   const peptide = alignedSequenceColumn.get(currentTable.currentRowIdx);
   return peptideMolfile(peptide);
 }
@@ -242,51 +226,49 @@ export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.
 }
 
 //name: Test multiple sequence alignment for any column
-//input: dataframe table
+//input: dataframe _table
 //input: column col
 //output: column result
-export async function runTestMSAEnoughMemory(table: DG.DataFrame, col: DG.Column) {
+export async function runTestMSAEnoughMemory(_table: DG.DataFrame, col: DG.Column<string>): Promise<DG.Column<string>> {
   await testMSAEnoughMemory(col);
   return col;
 }
 
-//name: Substitution
+//name: Get Peptides Structure
 //tags: panel, widgets
-//input: dataframe table {semType: Substitution}
-//output: widget result
-export async function peptideSubstitution(table: DG.DataFrame): Promise<DG.Widget> {
-  if (!table.temp[C.PEPTIDES_ANALYSIS])
-    return new DG.Widget(ui.divText('This widget is only applicable for peptides analysis'));
-  return substitutionsWidget(table);
-}
-
-//name: Distribution
-//tags: panel, widgets
-//input: dataframe table {semType: viewerTable}
+//input: column col {semType: alignedSequence}
 //output: widget result
-export function peptideDistribution(table: DG.DataFrame): DG.Widget {
-  if (!table.temp[C.PEPTIDES_ANALYSIS])
-    return new DG.Widget(ui.divText('This widget is only applicable for peptides analysis'));
-  return getDistributionWidget(table);
+export function getPeptidesStructure(col: DG.Column): DG.Widget {
+  const getButtonTooltip = 'Retrieves peptides structure from customer database by special id column';
+  const getButton = ui.button('Get structure', async () => {
+    const progress = DG.TaskBarProgressIndicator.create('Getting structure...');
+    try {
+      const params = {peptidesTable: col.dataFrame};
+      const result = await grok.functions.call('Customerextensions:getPeptidesStructure', params);
+      const text = result ? 'Structure retreived' : 'Structure retreivial is not possible';
+      grok.shell.info(text);
+    } catch (e) {
+      console.warn(e);
+    } finally {
+      progress.close();
+    }
+  }, getButtonTooltip);
+  return new DG.Widget(getButton);
 }
 
 //name: alignedSequenceDifferenceCellRenderer
-//tags: cellRenderer, cellRenderer-alignedSequenceDifference
-//meta-cell-renderer-sem-type: alignedSequenceDifference
+//tags: cellRenderer
+//meta.cellType: alignedSequenceDifference
 //output: grid_cell_renderer result
-export function alignedSequenceDifferenceCellRenderer() {
+export function alignedSequenceDifferenceCellRenderer(): AlignedSequenceDifferenceCellRenderer {
   return new AlignedSequenceDifferenceCellRenderer();
 }
 
-function getOrDefine(
-  view?: DG.TableView, grid?: DG.Grid, dataframe?: DG.DataFrame, column?: DG.Column | null,
-): [DG.TableView, DG.Grid, DG.DataFrame, DG.Column] {
-  view ??= (grok.shell.v as DG.TableView);
-  grid ??= view.grid;
+function getOrDefine(dataframe?: DG.DataFrame, column?: DG.Column | null): [DG.DataFrame, DG.Column] {
   dataframe ??= grok.shell.t;
-  column ??= (dataframe.columns as DG.ColumnList).bySemType(C.SEM_TYPES.ALIGNED_SEQUENCE);
+  column ??= dataframe.columns.bySemType(C.SEM_TYPES.ALIGNED_SEQUENCE);
   if (column === null)
     throw new Error('Table does not contain aligned sequence columns');
 
-  return [view, grid, dataframe, column];
+  return [dataframe, column];
 }

package/src/tests/core.ts

@@ -0,0 +1,67 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {category, test, expect} from '@datagrok-libraries/utils/src/test';
+
+import {_package} from '../package-test';
+import {startAnalysis} from '../widgets/analyze-peptides';
+import {PeptidesModel} from '../model';
+import * as C from '../utils/constants';
+
+category('Core', () => {
+  let simpleTable: DG.DataFrame;
+  let simpleActivityCol: DG.Column<number>;
+  let simpleAlignedSeqCol: DG.Column<string>;
+  let simpleScaledDf: DG.DataFrame;
+  let simpleScaledColName: string;
+
+  let complexTable: DG.DataFrame;
+  let complexActivityCol: DG.Column<number>;
+  let complexAlignedSeqCol: DG.Column<string>;
+  let complexScaledDf: DG.DataFrame;
+  let complexScaledColName: string;
+  const alignedSeuqnceCol = 'AlignedSequence';
+
+  let model: PeptidesModel | null = null;
+
+  test('Start analysis: simple', async () => {
+    const simpleActivityColName = 'IC50';
+    simpleTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned.csv'));
+    simpleActivityCol = simpleTable.getCol(simpleActivityColName);
+    simpleAlignedSeqCol = simpleTable.getCol(alignedSeuqnceCol);
+    simpleAlignedSeqCol.semType = C.SEM_TYPES.ALIGNED_SEQUENCE;
+    [simpleScaledDf, simpleScaledColName] =
+      await PeptidesModel.scaleActivity('-lg', simpleTable, simpleActivityColName, true);
+
+    model = await startAnalysis(
+      simpleActivityCol, simpleAlignedSeqCol, simpleTable, simpleScaledDf, simpleScaledColName, _package);
+    expect(model instanceof PeptidesModel, true);
+
+    if (model != null) {
+      model.currentSelection = {'11': ['D']};
+      grok.shell.closeTable(model._dataFrame);
+    }
+  });
+
+  test('Start analysis: сomplex', async () => {
+    const measureCategory = 'interleukin 23 receptor_h_wt_DC_HEK293_SPR_biotin_BIND Dose Response (Kd (uM):koff)';
+    const complexActivityColName = 'Value';
+    complexTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned_2.csv'));
+    const measuredCol: DG.Column<string> = complexTable.getCol('Measured');
+    complexTable.filter.init((idx) => measuredCol.get(idx) == measureCategory);
+    complexActivityCol = complexTable.getCol(complexActivityColName);
+    complexAlignedSeqCol = complexTable.getCol(alignedSeuqnceCol);
+    complexAlignedSeqCol.semType = C.SEM_TYPES.ALIGNED_SEQUENCE;
+    [complexScaledDf, complexScaledColName] =
+      await PeptidesModel.scaleActivity('-lg', complexTable, complexActivityColName, true);
+
+    model = await startAnalysis(
+      complexActivityCol, complexAlignedSeqCol, complexTable, complexScaledDf, complexScaledColName, _package);
+    expect(model instanceof PeptidesModel, true);
+
+    if (model != null) {
+      model.currentSelection = {'13': ['-']};
+      grok.shell.closeTable(model._dataFrame);
+    }
+  });
+});

package/src/tests/msa-tests.ts

@@ -12,16 +12,16 @@ export const _package = new DG.Package();
 
 let table: DG.DataFrame;
 
-category('peptides', async () => {
+category('MSA', 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 () => {
+  test('test_table.is_not_empty', async () => {
     _testTableIsNotEmpty(table);
   });
 
-  test('MSA.is_correct', async () => {
+  test('is_correct', async () => {
     _testMSAIsCorrect(alignedSequencesColumn);
   });
 });

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

@@ -1,4 +1,4 @@
-import {/*before, after, */category, test} from '@datagrok-libraries/utils/src/test';
+import {/*before, after, */after, category, test} from '@datagrok-libraries/utils/src/test';
 import {
   _testViewerIsDrawing,
   _testDimensionalityReducer,
@@ -12,66 +12,86 @@ 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();
+import {computeWeights} from '../viewers/peptide-space-viewer';
+import {_package} from '../package-test';
 
 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 () => {
-  /*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);
-  });*/
-
-  //table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');
+category('Peptide space', async () => {
   table = DG.DataFrame.fromCsv(aligned1);
-  view = grok.shell.addTableView(table);
 
-  test('peptide_space.test_table.is_not_empty', async () => {
+  test('test_table.is_not_empty', async () => {
     _testTableIsNotEmpty(table);
   });
 
-  test('peptide_space.PeptideSimilaritySpaceWidget.is_drawing', async () => {
+  test('PeptideSimilaritySpaceWidget.is_drawing', async () => {
+    view = grok.shell.addTableView(table);
     await _testViewerIsDrawing(table, view);
   });
 
   const alignedSequencesColumn = table.getCol('AlignedSequence');
-  const columnData = cleanAlignedSequencesColumn(alignedSequencesColumn);
 
-  for (const method of DimensionalityReducer.availableMethods) {
-    for (const measure of DimensionalityReducer.availableMetricsByType('String')) {
-      test(`peptide_space.DimensinalityReducer.${method}.${measure}.is_numeric`, async () => {
-        await _testDimensionalityReducer(columnData, method as StringMetrics, measure);
-      });
+  test('test_deminsionality_reducer', async () => {
+    const columnData = cleanAlignedSequencesColumn(alignedSequencesColumn);
+    for (const method of DimensionalityReducer.availableMethods) {
+      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.availableMetricsByType('String')) {
-      test(`peptide_space.PeptideSimilaritySpaceViewer.${method}.${measure}.is_proper`, async () => {
-        await _testPeptideSimilaritySpaceViewer(table, alignedSequencesColumn, method, measure, 100);//, view);
-      });
+  test('test_peptide_similarity_space_viewer', async () => {
+    for (const method of DimensionalityReducer.availableMethods) {
+      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!);
-  });*/
+  after(async () => {
+    view?.close();
+  });
+});
+
+category('Peptide Space Performance', () => {
+  test('test_compute_weights_performance', async () => {
+    const table = DG.DataFrame.fromCsv(await _package.files.readAsText('peptides_large.csv'));
+    const results: {[key: string]: {[key: string]: {[key: string]: number}}} = {};
+    const slice_volumes = [1, 2, 3, 4, 5, 7, 10];
+    const methods = DimensionalityReducer.availableMethods;
+    const metrics = DimensionalityReducer.availableMetricsByType('String');
+    const total_runs = slice_volumes.length * methods.length * metrics.length;
+    console.log('Started Peptide Space Performance benchmark...');
+
+    let run = 0;
+    for (const slice of slice_volumes) {
+      const bitset = DG.BitSet.create(table.rowCount, (i) => i < slice * 1000);
+      const table_slice = table.clone(bitset);
+      const col = table_slice.getCol('sequence');
+      const methodObj: {[key: string]: {[key: string]: number}} = {};
+
+      for (const method of methods) {
+        const measureObj: {[key: string]: number} = {};
+
+        for (const metric of metrics) {
+          console.log(`Run ${run++}/${total_runs}`);
+
+          const start = new Date();
+          await computeWeights(table_slice, method, metric, 100, col);
+          const stop = new Date();
+
+          measureObj[metric] = stop.getTime() - start.getTime();
+        }
+        methodObj[method] = measureObj;
+      }
+      results[`${slice}k`] = methodObj;
+    }
+    console.log('Peptide Space Performance benchmark finished...');
+    console.log(results);
+  });
 });