@datagrok/peptides 1.11.3 → 1.12.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/peptides",
   "friendlyName": "Peptides",
-  "version": "1.11.3",
+  "version": "1.12.0",
   "author": {
     "name": "Volodymyr Dyma",
     "email": "vdyma@datagrok.ai"
@@ -13,7 +13,7 @@
     "directory": "packages/Peptides"
   },
   "dependencies": {
-    "@datagrok-libraries/bio": "^5.36.1",
+    "@datagrok-libraries/bio": "^5.37.0",
     "@datagrok-libraries/ml": "^6.3.39",
     "@datagrok-libraries/statistics": "^1.2.2",
     "@datagrok-libraries/utils": "^4.1.4",

package/src/model.ts

@@ -7,6 +7,7 @@ import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import {MonomerWorks} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
 import {pickUpPalette, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {calculateScores, SCORE} from '@datagrok-libraries/bio/src/utils/macromolecule/scoring';
 import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
 import {DistanceMatrix} from '@datagrok-libraries/ml/src/distance-matrix';
 import {StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
@@ -21,20 +22,18 @@ import $ from 'cash-dom';
 
 import * as C from './utils/constants';
 import * as type from './utils/types';
-import {calculateSelected, extractColInfo, scaleActivity, getStatsSummary, prepareTableForHistogram, getTemplate} from './utils/misc';
+import {calculateSelected, extractColInfo, scaleActivity, getStatsSummary, prepareTableForHistogram} from './utils/misc';
 import {MONOMER_POSITION_PROPERTIES, MonomerPosition, MostPotentResidues} from './viewers/sar-viewer';
 import * as CR from './utils/cell-renderer';
 import {mutationCliffsWidget} from './widgets/mutation-cliffs';
-import {getActivityDistribution, getDistributionLegend, getDistributionWidget, getStatsTableMap,
-} from './widgets/distribution';
+import {getActivityDistribution, getDistributionLegend, getDistributionWidget, getStatsTableMap} from './widgets/distribution';
 import {getAggregatedValue, getStats, Stats} from './utils/statistics';
 import {LogoSummaryTable} from './viewers/logo-summary';
 import {getSettingsDialog} from './widgets/settings';
 import {_package, getMonomerWorksInstance, getTreeHelperInstance} from './package';
 import {findMutations} from './utils/algorithms';
 import {createDistanceMatrixWorker} from './utils/worker-creator';
-import {calculateIdentity, calculateSimilarity} from './widgets/similarity';
-import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {getSelectionWidget} from './widgets/selection';
 
 export type SummaryStats = {
   minCount: number, maxCount: number,
@@ -98,7 +97,8 @@ export class PeptidesModel {
   _distanceMatrix!: DistanceMatrix;
   _dm!: DistanceMatrix;
   _layoutEventInitialized = false;
-  isToolboxSet: boolean = false;
+
+  subs: rxjs.Subscription[] = [];
 
   private constructor(dataFrame: DG.DataFrame) {
     this.df = dataFrame;
@@ -442,26 +442,29 @@ export class PeptidesModel {
       acc.addPane('Actions', () => {
         const newView = ui.label('New view');
         $(newView).addClass('d4-link-action');
-        newView.onclick = () => trueModel.createNewView();
-        newView.onmouseover = (ev) => ui.tooltip.show('Creates a new view from current selection', ev.clientX + 5, ev.clientY + 5);
+        newView.onclick = (): string => trueModel.createNewView();
+        newView.onmouseover =
+          (ev): void => ui.tooltip.show('Creates a new view from current selection', ev.clientX + 5, ev.clientY + 5);
         const newCluster = ui.label('New cluster');
         $(newCluster).addClass('d4-link-action');
-        newCluster.onclick = () => {
+        newCluster.onclick = (): void => {
           const lstViewer = trueModel.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
           if (lstViewer === null)
             throw new Error('Logo summary table viewer is not found');
           lstViewer.clusterFromSelection();
         };
-        newCluster.onmouseover = (ev) => ui.tooltip.show('Creates a new cluster from selection', ev.clientX + 5, ev.clientY + 5);
+        newCluster.onmouseover =
+          (ev): void => ui.tooltip.show('Creates a new cluster from selection', ev.clientX + 5, ev.clientY + 5);
         const removeCluster = ui.label('Remove cluster');
         $(removeCluster).addClass('d4-link-action');
-        removeCluster.onclick = () => {
+        removeCluster.onclick = (): void => {
           const lstViewer = trueModel.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
           if (lstViewer === null)
             throw new Error('Logo summary table viewer is not found');
           lstViewer.removeCluster();
         };
-        removeCluster.onmouseover = (ev) => ui.tooltip.show('Removes currently selected custom cluster', ev.clientX + 5, ev.clientY + 5);
+        removeCluster.onmouseover =
+          (ev): void => ui.tooltip.show('Removes currently selected custom cluster', ev.clientX + 5, ev.clientY + 5);
         removeCluster.style.visibility = trueModel.clusterSelection.length === 0 ||
           !wu(this.customClusters).some((c) => trueModel.clusterSelection.includes(c.name)) ? 'hidden' : 'visible';
         return ui.divV([newView, newCluster, removeCluster]);
@@ -470,6 +473,7 @@ export class PeptidesModel {
     const table = trueModel.df.filter.anyFalse ? trueModel.df.clone(trueModel.df.filter, null, true) : trueModel.df;
     acc.addPane('Mutation Cliffs pairs', () => mutationCliffsWidget(trueModel.df, trueModel).root);
     acc.addPane('Distribution', () => getDistributionWidget(table, trueModel).root);
+    acc.addPane('Selection', () => getSelectionWidget(trueModel.df, trueModel).root);
 
     return acc;
   }
@@ -1107,80 +1111,47 @@ export class PeptidesModel {
       this.updateGrid();
     }
 
-    if (!this.isToolboxSet && this.df.getTag(C.TAGS.MULTIPLE_VIEWS) !== '1') {
-      let template: ISeqSplitted;
-      const sequencesCol = this.df.getCol(this.settings.sequenceColumnName!);
-      const minTemplateLength = this.splitSeqDf.columns.toList()
-        .filter((col) => col.stats.missingValueCount === 0).length;
-      const calculateIdentityBtn = ui.button('Identity', async () => {
-        let identityScoresCol = calculateIdentity(template, this.splitSeqDf);
-        identityScoresCol.name = this.df.columns.getUnusedName(identityScoresCol.name);
-        identityScoresCol = this.df.columns.add(identityScoresCol);
-        identityScoresCol.setTag(C.TAGS.IDENTITY_TEMPLATE, new Array(template).join(' '));
-      }, 'Calculate identity');
-      const calculateSimilarityBtn = ui.button('Similarity', async () => {
-        let similarityScoresCol = await calculateSimilarity(template, this.splitSeqDf);
-        similarityScoresCol.name = this.df.columns.getUnusedName(similarityScoresCol.name);
-        similarityScoresCol = this.df.columns.add(similarityScoresCol);
-        similarityScoresCol.setTag(C.TAGS.SIMILARITY_TEMPLATE, new Array(template).join(' '));
-      }, 'Calculate similarity');
-      const templateInput = ui.stringInput('Template', this.identityTemplate, async () => {
-        this.identityTemplate = templateInput.value;
-        if (isNaN(parseInt(templateInput.value))) {
-          if (templateInput.value.length === 0) {
-            calculateIdentityBtn.disabled = true;
-            calculateSimilarityBtn.disabled = true;
-            return;
-          }
-          try {
-            template ??= await getTemplate(this.identityTemplate, sequencesCol);
-            if (template.length < minTemplateLength) {
-              grok.shell.warning(`Template length should be at least ${minTemplateLength} amino acids.`);
-              calculateIdentityBtn.disabled = true;
-              calculateSimilarityBtn.disabled = true;
-              return;
-            } else if (new Array(template).includes('') || new Array(template).includes('-')) {
-              grok.shell.warning('Template shouldn\'t contain gaps or empty cells.');
-              calculateIdentityBtn.disabled = true;
-              calculateSimilarityBtn.disabled = true;
-              return;
-            }
-          } catch (e) {
-            grok.shell.warning(`Only ${sequencesCol.getTag(DG.TAGS.UNITS)} sequence format is supported.`);
-            grok.log.warning(e as string);
-            calculateIdentityBtn.disabled = true;
-            return;
-          }
-        } else {
-          const rowIndex = parseInt(templateInput.value) - 1;
-          const selectedIndexes = this.df.filter.getSelectedIndexes();
-          if (rowIndex < 0 || rowIndex >= selectedIndexes.length) {
-            grok.shell.warning('Invalid row index');
-            calculateIdentityBtn.disabled = true;
-            calculateSimilarityBtn.disabled = true;
-            return;
-          }
-          this.identityTemplate = sequencesCol.get(selectedIndexes[rowIndex]);
-        }
-        try {
-          template = await getTemplate(this.identityTemplate, sequencesCol);
-        } catch (e) {
-          grok.shell.warning('Couldn\'t recognize sequence format.');
-          grok.log.warning(e as string);
-          calculateIdentityBtn.disabled = true;
-          calculateSimilarityBtn.disabled = true;
-          return;
-        }
-        calculateIdentityBtn.disabled = false;
-        calculateSimilarityBtn.disabled = false;
-      }, {placeholder: 'Sequence or row index...'});
-      templateInput.setTooltip('Template sequence. Can be row index, peptide ID or sequence.');
-      templateInput.fireChanged();
-      const acc = this.analysisView.toolboxPage.accordion;
-      acc.addPane('Sequence Identity and Similarity',
-        () => ui.divV([ui.form([templateInput]), calculateIdentityBtn, calculateSimilarityBtn]), true, acc.panes[0]);
-      this.isToolboxSet = true;
-    }
+    this.subs.push(grok.events.onAccordionConstructed.subscribe((acc) => {
+      if (!(grok.shell.o instanceof DG.SemanticValue || (grok.shell.o instanceof DG.Column && this.df.columns.toList().includes(grok.shell.o))))
+        return;
+
+      const actionsPane = acc.getPane('Actions');
+
+      const actionsHost = $(actionsPane.root).find('.d4-flex-col');
+      const calculateIdentity = ui.label('Calculate identity');
+      calculateIdentity.classList.add('d4-link-action');
+      ui.tooltip.bind(calculateIdentity, 'Adds a column with fractions of matching monomers against sequence in the current row');
+      calculateIdentity.onclick = (): void => {
+        const seqCol = this.df.getCol(this.settings.sequenceColumnName!);
+        calculateScores(this.df, seqCol, seqCol.get(this.df.currentRowIdx), SCORE.IDENTITY);
+      };
+      actionsHost.append(ui.span([calculateIdentity], 'd4-markdown-row'));
+
+      const calculateSimilarity = ui.label('Calculate similarity');
+      calculateSimilarity.classList.add('d4-link-action');
+      ui.tooltip.bind(calculateSimilarity, 'Adds a column with sequence similarity scores against sequence in the current row');
+      calculateSimilarity.onclick = (): void => {
+        const seqCol = this.df.getCol(this.settings.sequenceColumnName!);
+        calculateScores(this.df, seqCol, seqCol.get(this.df.currentRowIdx), SCORE.SIMILARITY);
+      };
+      actionsHost.append(ui.span([calculateSimilarity], 'd4-markdown-row'));
+    }));
+
+    this.subs.push(grok.events.onViewRemoved.subscribe((view) => {
+      if (view.id === this.analysisView.id)
+        this.subs.forEach((v) => v.unsubscribe());
+      grok.log.debug(`Peptides: view ${view.name} removed`);
+    }));
+    this.subs.push(grok.events.onTableRemoved.subscribe((table: DG.DataFrame) => {
+      if (table.id === this.df.id)
+        this.subs.forEach((v) => v.unsubscribe());
+      grok.log.debug(`Peptides: table ${table.name} removed`);
+    }));
+    this.subs.push(grok.events.onProjectClosed.subscribe((project: DG.Project) => {
+      if (project.id === grok.shell.project.id)
+        this.subs.forEach((v) => v.unsubscribe());
+      grok.log.debug(`Peptides: project ${project.name} closed`);
+    }));
 
     this.fireBitsetChanged(true);
     if (typeof this.settings.targetColumnName === 'undefined')

package/src/package.ts

@@ -8,7 +8,6 @@ import {PeptideSimilaritySpaceWidget} from './utils/peptide-similarity-space';
 import {manualAlignmentWidget} from './widgets/manual-alignment';
 import {MonomerPosition, MostPotentResidues} from './viewers/sar-viewer';
 import {getTreeHelper, ITreeHelper} from '@datagrok-libraries/bio/src/trees/tree-helper';
-import {IDendrogramService, getDendrogramService} from '@datagrok-libraries/bio/src/trees/dendrogram';
 import {PeptideSpaceViewer} from './viewers/peptide-space-viewer';
 import {LogoSummaryTable} from './viewers/logo-summary';
 import {MonomerWorks} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';

package/src/tests/widgets.ts

@@ -1,10 +1,10 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {category, test, before, expect, awaitCheck, expectFloat} from '@datagrok-libraries/utils/src/test';
+import {category, test, before, expect, awaitCheck} from '@datagrok-libraries/utils/src/test';
 import {_package} from '../package-test';
 import {PeptidesModel, VIEWER_TYPE} from '../model';
-import {getTemplate, scaleActivity} from '../utils/misc';
+import {scaleActivity} from '../utils/misc';
 import {startAnalysis} from '../widgets/peptides';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import * as C from '../utils/constants';
@@ -14,7 +14,6 @@ import {mutationCliffsWidget} from '../widgets/mutation-cliffs';
 import {TEST_COLUMN_NAMES} from './utils';
 import wu from 'wu';
 import {LogoSummaryTable} from '../viewers/logo-summary';
-import {calculateIdentity, calculateSimilarity} from '../widgets/similarity';
 
 category('Widgets: Settings', () => {
   let df: DG.DataFrame;
@@ -237,54 +236,3 @@ category('Widgets: Actions', () => {
       'Expected to have no custom cluster in the Logo Summary Table');
   });
 }, {clear: false});
-
-
-category('Widgets: Identity', () => {
-  let df: DG.DataFrame;
-  let model: PeptidesModel;
-  let activityCol: DG.Column<number>;
-  let sequenceCol: DG.Column<string>;
-  let clusterCol: DG.Column<any>;
-  let scaledActivityCol: DG.Column<number>;
-
-  before(async () => {
-    df = DG.DataFrame.fromCsv(await _package.files.readAsText('tests/HELM_small.csv'));
-    activityCol = df.getCol(TEST_COLUMN_NAMES.ACTIVITY);
-    sequenceCol = df.getCol(TEST_COLUMN_NAMES.SEQUENCE);
-    sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
-    sequenceCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
-    scaledActivityCol = scaleActivity(activityCol, C.SCALING_METHODS.NONE);
-    clusterCol = df.getCol(TEST_COLUMN_NAMES.CLUSTER);
-    const tempModel = await startAnalysis(activityCol, sequenceCol, clusterCol, df, scaledActivityCol,
-      C.SCALING_METHODS.NONE);
-    if (tempModel === null)
-      throw new Error('Model is null');
-    model = tempModel;
-    let overlayInit = false;
-    model._analysisView!.grid.onAfterDrawOverlay.subscribe(() => overlayInit = true);
-
-    // Ensure grid finished initializing to prevent Unhandled exceptions
-    let accrodionInit = false;
-    grok.events.onAccordionConstructed.subscribe((_) => accrodionInit = true);
-    await awaitCheck(() => model!.df.currentRowIdx === 0, 'Grid cell never finished initializing', 2000);
-    await awaitCheck(() => grok.shell.o instanceof DG.Column, 'Shell object never changed', 2000);
-    await awaitCheck(() => accrodionInit, 'Accordion never finished initializing', 2000);
-    await awaitCheck(() => overlayInit, 'Overlay never finished initializing', 2000);
-  });
-
-  test('Identity', async () => {
-    const seq = 'PEPTIDE1{meI.hHis.Aca.N.T.dE.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$$';
-    const template = await getTemplate(seq);
-    const identityCol = calculateIdentity(template, model.splitSeqDf);
-    expect(identityCol.get(0), 1, 'Expected 1 identity score when sequence is matching template');
-    expectFloat(identityCol.get(3)!, 0.5625, 0.01, 'Expected 0.5625 identity score agains sequence at position 3');
-  });
-
-  test('Similarity', async () => {
-    const seq = 'PEPTIDE1{meI.hHis.Aca.N.T.dE.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$$';
-    const template = await getTemplate(seq);
-    const identityCol = await calculateSimilarity(template, model.splitSeqDf);
-    expect(identityCol.get(0), 1, 'Expected 1 identity score when sequence is matching template');
-    expectFloat(identityCol.get(3)!, 0, 0.001, 'Expected 7 identity score agains sequence at position 3');
-  })
-});

package/src/utils/misc.ts

@@ -3,9 +3,9 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import * as C from './constants';
 import * as type from './types';
-import {getSplitterForColumn} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
-import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {getSplitter} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
+import {TAGS as bioTags} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 export function getTypedArrayConstructor(
   maxNum: number): Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor {
@@ -101,13 +101,3 @@ export function prepareTableForHistogram(table: DG.DataFrame): DG.DataFrame {
     DG.Column.fromList(DG.TYPE.BOOL, C.COLUMNS_NAMES.SPLIT_COL, expandedMasks),
   ]);
 }
-
-export async function getTemplate(sequence: string, seqCol?: DG.Column<string>): Promise<ISeqSplitted> {
-  if (typeof seqCol === 'undefined') {
-    const tempDf = DG.DataFrame.fromCsv(`sequence\n${new Array(10).fill(sequence).join('\n')}`);
-    await grok.data.detectSemanticTypes(tempDf);
-    seqCol = tempDf.getCol('sequence');
-  }
-  const splitter = getSplitterForColumn(seqCol);
-  return splitter(sequence);
-}

package/src/viewers/sar-viewer.ts

@@ -121,6 +121,7 @@ export class MonomerPosition extends DG.JsViewer {
           mutationCliffsMode.value = true;
           this.mode = MONOMER_POSITION_MODE.MUTATION_CLIFFS;
         });
+        mutationCliffsMode.setTooltip('Statistically significant changes in activity');
         mutationCliffsMode.addPostfix(MONOMER_POSITION_MODE.MUTATION_CLIFFS);
         const invariantMapMode = ui.boolInput('', this.mode === MONOMER_POSITION_MODE.INVARIANT_MAP);
         invariantMapMode.root.addEventListener('click', () => {
@@ -128,6 +129,7 @@ export class MonomerPosition extends DG.JsViewer {
           invariantMapMode.value = true;
           this.mode = MONOMER_POSITION_MODE.INVARIANT_MAP;
         });
+        invariantMapMode.setTooltip('Number of sequences having monomer-position');
         invariantMapMode.addPostfix(MONOMER_POSITION_MODE.INVARIANT_MAP);
         const setDefaultProperties = (input: DG.InputBase): void => {
           $(input.root).find('.ui-input-editor').css('margin', '0px').attr('type', 'radio');

package/src/widgets/distribution.ts

@@ -195,10 +195,12 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
 
   const splitByPosition = ui.boolInput('', defaultValuePos, updateDistributionHost);
   splitByPosition.addPostfix('Split by position');
+  splitByPosition.setTooltip('Constructs distribution for each position separately');
   setDefaultProperties(splitByPosition);
   $(splitByPosition.root).css('margin-right', '10px');
   const splitByAAR = ui.boolInput('', defaultValueAAR, updateDistributionHost);
   splitByAAR.addPostfix('Split by monomer');
+  splitByAAR.setTooltip('Constructs distribution for each monomer separately');
   setDefaultProperties(splitByAAR);
 
   const controlsHost = ui.divH([splitByPosition.root, splitByAAR.root]);

package/src/widgets/manual-alignment.ts

@@ -8,7 +8,6 @@ import {PeptidesModel} from '../model';
 import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
 
 /** Manual sequence alignment widget.
- *
  * @param {DG.Column} alignedSequenceCol Aligned sequence column
  * @param {DG.DataFrame} currentDf Working table
  * @return {DG.Widget} Widget for manual sequence alignment */
@@ -32,13 +31,10 @@ export function manualAlignmentWidget(alignedSequenceCol: DG.Column<string>, cur
 
     const peptidesController = PeptidesModel.getInstance(currentDf);
     peptidesController.updateGrid();
-  });
+  }, 'Apply changes');
 
-  const resetBtn = ui.button(
-    ui.iconFA('redo'),
-    () => sequenceInput.value = alignedSequenceCol.get(currentDf.currentRowIdx)!,
-    'Reset',
-  );
+  const resetBtn = ui.button(ui.iconFA('redo'),
+    () => sequenceInput.value = alignedSequenceCol.get(currentDf.currentRowIdx)!, 'Reset');
   $(resetBtn).addClass('pep-snippet-editor-icon pep-reset-icon');
 
   return new DG.Widget(ui.divV([resetBtn, sequenceInput.root, applyChangesBtn], 'pep-textarea-box'));

package/src/widgets/peptides.ts

@@ -16,13 +16,12 @@ import {ALIGNMENT, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/
  * @param {DG.DataFrame} df Working table
  * @param {DG.Column} col Aligned sequence column
  * @return {Promise<DG.Widget>} Widget containing peptide analysis */
-export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>):
-  { host: HTMLElement, callback: () => Promise<boolean> } {
+export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): {host: HTMLElement, callback: () => Promise<boolean>} {
   const logoHost = ui.div();
-  // logoHost.style.alignContent = 'center';
   let seqColInput: DG.InputBase | null = null;
   if (typeof col === 'undefined') {
-    const sequenceColumns = df.columns.toList().filter((dfCol) => dfCol.semType === DG.SEMTYPE.MACROMOLECULE);
+    const sequenceColumns = df.columns.toList()
+      .filter((dfCol) => dfCol.semType === DG.SEMTYPE.MACROMOLECULE && dfCol.stats.missingValueCount === 0);
     const potentialCol = DG.Utils.firstOrNull(sequenceColumns);
     if (potentialCol === null)
       throw new Error('Peptides Error: table doesn\'t contain sequence columns');
@@ -39,7 +38,8 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>):
         return viewer.root;
       }));
       //TODO: add when new version of datagrok-api is available
-    }, {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE});
+    }, {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE && col.stats.missingValueCount === 0});
+    seqColInput.setTooltip('Macromolecule column in FASTA, HELM or separated format');
   } else if (!(col.getTag(bioTAGS.aligned) === ALIGNMENT.SEQ_MSA) &&
     col.getTag(DG.TAGS.UNITS) !== NOTATION.HELM) {
     return {
@@ -65,10 +65,8 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>):
   }
 
   let scaledCol: DG.Column<number>;
-
-  const defaultActivityColumn: DG.Column<number> | null =
-    df.col('activity') || df.col('IC50') || DG.Utils.firstOrNull(df.columns.numerical);
-  ;
+  const defaultActivityColumn: DG.Column<number> | null = df.col('activity') || df.col('IC50') ||
+    DG.Utils.firstOrNull(df.columns.numerical);
   const histogramHost = ui.div([], {id: 'pep-hist-host'});
 
   const activityScalingMethod = ui.choiceInput(
@@ -88,23 +86,26 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>):
       histogramHost.lastChild?.remove();
       histogramHost.appendChild(hist.root);
     }) as DG.InputBase<C.SCALING_METHODS | null>;
-  activityScalingMethod.setTooltip('Function to apply for each value in activity column');
+  activityScalingMethod.setTooltip('Activity column transformation method');
 
   const activityScalingMethodState = (): void => {
-    activityScalingMethod.enabled = (activityColumnChoice.value ?? false) &&
-      DG.Stats.fromColumn(activityColumnChoice.value!).min > 0;
-    activityScalingMethod.fireChanged();
+    activityScalingMethod.enabled = (activityColumnChoice.value ?? false) && DG.Stats.fromColumn(activityColumnChoice.value!).min > 0;
+    activityScalingMethod.value = C.SCALING_METHODS.NONE;
   };
   //TODO: add when new version of datagrok-api is available
   const activityColumnChoice = ui.columnInput('Activity', df, defaultActivityColumn, activityScalingMethodState,
-    {filter: (col: DG.Column) => col.type === DG.TYPE.INT || col.type === DG.TYPE.FLOAT});
-  const clustersColumnChoice = ui.columnInput('Clusters', df, null);
+    {filter: (col: DG.Column) => (col.type === DG.TYPE.INT || col.type === DG.TYPE.FLOAT) && col.stats.missingValueCount === 0});
+  activityColumnChoice.setTooltip('Numerical activity column');
+  const clustersColumnChoice = ui.columnInput('Clusters', df, null, null, {filter: (col: DG.Column) => col.stats.missingValueCount === 0});
+  clustersColumnChoice.setTooltip('Optional. Clusters column is used to create Logo Summary Table');
   clustersColumnChoice.nullable = true;
   activityColumnChoice.fireChanged();
   activityScalingMethod.fireChanged();
 
   const targetColumnChoice = ui.columnInput('Target', df, null, null,
-    {filter: (col: DG.Column) => col.type === DG.TYPE.STRING});
+    {filter: (col: DG.Column) => col.type === DG.TYPE.STRING && col.stats.missingValueCount === 0});
+  targetColumnChoice.setTooltip('Optional. Target represents a unique binding construct for every peptide in the data. ' +
+    'Target can be used to split mutation cliff analysis for peptides specific to a certain set of targets');
   targetColumnChoice.nullable = true;
 
   const inputsList = [activityColumnChoice, activityScalingMethod, clustersColumnChoice, targetColumnChoice];
@@ -128,7 +129,7 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>):
   const inputElements: HTMLElement[] = [ui.inputs(inputsList)];
   $(inputElements[0]).find('label').css('width', 'unset');
   if (typeof col !== 'undefined') {
-    const startBtn = ui.button('Launch SAR', startAnalysisCallback);
+    const startBtn = ui.button('Launch SAR', startAnalysisCallback, '');
     startBtn.style.alignSelf = 'center';
     inputElements.push(startBtn);
     bottomHeight = '215px';

package/src/widgets/selection.ts

@@ -0,0 +1,31 @@
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {PeptidesModel} from '../model';
+
+import wu from 'wu';
+
+export function getSelectionWidget(table: DG.DataFrame, model: PeptidesModel): DG.Widget {
+  const compBitset = model.getCompoundBitset();
+  if (compBitset.trueCount === 0)
+    return new DG.Widget(ui.divText('No compounds selected'));
+  const newTable = DG.DataFrame.create(table.rowCount);
+  newTable.filter.copyFrom(compBitset);
+  const sourceGrid = model.analysisView.grid;
+  const numericalCols = wu(table.columns.numerical);
+  for (let gridColIdx = 1; gridColIdx < sourceGrid.columns.length; gridColIdx++) {
+    const gridCol = sourceGrid.columns.byIndex(gridColIdx)!;
+    if (!gridCol.visible)
+      continue;
+    const sourceCol = gridCol.column!;
+    const sourceColRawData = sourceCol.getRawData();
+    const sourceColCategories = sourceCol.categories;
+    const getValue = numericalCols.some((col) => col.name === sourceCol.name) ? (i: number): number => sourceColRawData[i] :
+      (i: number): string => sourceColCategories[sourceColRawData[i]];
+    const col = newTable.columns.addNewVirtual(gridCol.name, (i) => getValue(i), sourceCol.type as DG.TYPE);
+    for (const [tag, value] of sourceCol.tags)
+      col.setTag(tag, value);
+  }
+  const newGrid = newTable.plot.grid();
+  return new DG.Widget(ui.box(newGrid.root, {style: {width: '100%'}}));
+}

package/src/widgets/settings.ts

@@ -62,12 +62,17 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
   // General pane options
   const activityCol = ui.columnInput(GENERAL_INPUTS.ACTIVITY, model.df,
     model.df.getCol(model.settings.activityColumnName!), () => result.activityColumnName = activityCol.value!.name,
-    {filter: (col: DG.Column) => (col.type === DG.TYPE.FLOAT || col.type === DG.TYPE.INT) && col.name !== C.COLUMNS_NAMES.ACTIVITY_SCALED});
+    {filter: (col: DG.Column) => (col.type === DG.TYPE.FLOAT || col.type === DG.TYPE.INT) &&
+      col.name !== C.COLUMNS_NAMES.ACTIVITY_SCALED && col.stats.missingValueCount === 0});
+  activityCol.setTooltip('Numeric activity column');
   const activityScaling =
     ui.choiceInput(GENERAL_INPUTS.ACTIVITY_SCALING, currentScaling, Object.values(C.SCALING_METHODS),
       () => result.scaling = activityScaling.value as C.SCALING_METHODS) as DG.InputBase<C.SCALING_METHODS>;
+  activityScaling.setTooltip('Activity column transformation method');
   const bidirectionalAnalysis = ui.boolInput(GENERAL_INPUTS.BIDIRECTIONAL_ANALYSIS, currentBidirectional,
     () => result.isBidirectional = bidirectionalAnalysis.value) as DG.InputBase<boolean>;
+  bidirectionalAnalysis.setTooltip('Distinguish between positive and negative mean activity difference in ' +
+    'Monomer-Position and Most Potent Residues viewers');
 
   accordion.addPane(SETTINGS_PANES.GENERAL, () => ui.inputs([activityCol, activityScaling, bidirectionalAnalysis]), true);
   inputs[SETTINGS_PANES.GENERAL] = [activityCol, activityScaling, bidirectionalAnalysis];
@@ -88,6 +93,7 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
   const isDendrogramEnabled = wu(model.analysisView.viewers).some((v) => v.type === VIEWER_TYPE.DENDROGRAM);
   const dendrogram = ui.boolInput(VIEWER_TYPE.DENDROGRAM, isDendrogramEnabled ?? false,
     () => result.showDendrogram = dendrogram.value) as DG.InputBase<boolean>;
+  dendrogram.setTooltip('Show dendrogram viewer');
   dendrogram.enabled = getTreeHelperInstance() !== null;
 
   accordion.addPane(SETTINGS_PANES.VIEWERS, () => ui.inputs([dendrogram]), true);
@@ -100,6 +106,7 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
     result.maxMutations = val;
     maxMutations.addPostfix(val.toString());
   }) as DG.InputBase<number>;
+  maxMutations.setTooltip('Maximum number of mutations between reference and mutated sequences');
   maxMutations.addPostfix((settings.maxMutations ?? 1).toString());
   const minActivityDelta = ui.sliderInput(MUTATION_CLIFFS_INPUTS.MIN_ACTIVITY_DELTA, currentMinActivityDelta, 0,
     100, () => {
@@ -108,6 +115,7 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
       $(minActivityDelta.root).find('label.ui-input-description').remove();
       minActivityDelta.addPostfix(val);
     }) as DG.InputBase<number>;
+  minActivityDelta.setTooltip('Minimum activity difference between reference and mutated sequences');
   minActivityDelta.addPostfix((settings.minActivityDelta ?? 0).toString());
   accordion.addPane(SETTINGS_PANES.MUTATION_CLIFFS, () => ui.inputs([maxMutations, minActivityDelta]), true);
   inputs[SETTINGS_PANES.MUTATION_CLIFFS] = [maxMutations, minActivityDelta];
@@ -131,6 +139,7 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
             delete result.columns;
         }
       }) as DG.InputBase<boolean>;
+    isIncludedInput.setTooltip('Include aggregated column value in tooltips, Logo Summary Table and Distribution panel');
 
     const aggregationInput = ui.choiceInput(COLUMNS_INPUTS.AGGREGATION, (currentColumns)[colName] ?? DG.AGG.AVG,
       Object.values(DG.STATS), () => {
@@ -143,6 +152,7 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
             delete result.columns;
         }
       }) as DG.InputBase<DG.AggregationType>;
+    aggregationInput.setTooltip('Aggregation method');
     $(aggregationInput.root).find('label').css('width', 'auto');
     const inputsRow = ui.inputsRow(col.name, [isIncludedInput, aggregationInput]);
     includedColumnsInputs.push(...[isIncludedInput, aggregationInput]);

package/src/widgets/similarity.ts

@@ -1,39 +0,0 @@
-
-import {sequenceChemSimilarity} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
-import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
-import * as DG from 'datagrok-api/dg';
-
-export function calculateIdentity(template: ISeqSplitted, splitSeqDf: DG.DataFrame): DG.Column<number> {
-  const numPositions = splitSeqDf.columns.length;
-  const positionCols: Uint32Array[] = new Array(numPositions);
-  const positionEmptyCategories: number[] = new Array(numPositions);
-  const categoryIndexesTemplate: number[] = new Array(numPositions);
-
-  for (let posIdx = 0; posIdx < numPositions; ++posIdx) {
-    const posCol = splitSeqDf.columns.byIndex(posIdx);
-    positionCols[posIdx] = posCol.getRawData() as Uint32Array;
-    positionEmptyCategories[posIdx] = posCol.categories.indexOf('');
-    categoryIndexesTemplate[posIdx] = posCol.categories.indexOf(template[posIdx] ?? '');
-  }
-
-  const identityScoresCol = DG.Column.float('Identity', splitSeqDf.rowCount);
-  const identityScoresData = identityScoresCol.getRawData();
-  for (let rowIndex = 0; rowIndex < splitSeqDf.rowCount; ++rowIndex) {
-    identityScoresData[rowIndex] = 0;
-    for (let posIdx = 0; posIdx < template.length; ++posIdx) {
-      const categoryIndex = positionCols[posIdx][rowIndex];
-      if (categoryIndex === categoryIndexesTemplate[posIdx])
-        ++identityScoresData[rowIndex];
-    }
-    identityScoresData[rowIndex] /= template.length;
-  }
-
-  return identityScoresCol;
-}
-
-
-export async function calculateSimilarity(template: ISeqSplitted, splitSeqDf: DG.DataFrame): Promise<DG.Column<number>> {
-  const columns = splitSeqDf.columns.toList() as DG.Column<string>[];
-  const scoresCol = await sequenceChemSimilarity(columns, template);
-  return scoresCol;
-}