@datagrok/proteomics 1.0.0 → 1.2.0

package/src/menu.ts

@@ -0,0 +1,133 @@
+/**
+ * Dynamic half of the **Proteomics** menu — the analysis groups that need a per-table
+ * grey-out, built onto a table view's ribbon.
+ *
+ * The menu is split across two mechanisms on purpose:
+ *
+ *   - In the **main Datagrok menu (left bar)**: only `Proteomics | Import`, via decorator
+ *     `top-menu` strings in `package.ts`. This is the always-available entry point,
+ *     reachable with no table open. The platform owns it — robust, never duplicates.
+ *   - In a **table view's ribbon**: the full menu (Import + Annotate / Analyze / Visualize
+ *     / Share), built here onto `view.ribbonMenu`, and ONLY when a Proteomics analysis
+ *     table is active. The analysis items need `isEnabled` grey-out (a Spectronaut
+ *     Candidates file has no per-sample intensities, so the sample-level steps don't apply),
+ *     which only works on a programmatically built menu.
+ *
+ * The two hosts are independent: a decorator `top-menu` populates `grok.shell.topMenu` (the
+ * left-bar menu), NOT `view.ribbonMenu`. When a view's ribbon has its own 'Proteomics'
+ * group, the ribbon shows THAT one — so Import has to be (re)added here for the ribbon copy.
+ * They don't collide because they live in different menus.
+ */
+import * as DG from 'datagrok-api/dg';
+
+/** Handlers the ribbon menu invokes — including Import, which the ribbon builds itself
+ * (the decorator copies only reach the left-bar main menu). Passed in from `package.ts`
+ * so this module doesn't import `PackageFunctions` (circular). */
+export interface ProteomicsMenuHandlers {
+  importSpectronautCandidates: () => void;
+  importSpectronaut: () => void;
+  importMaxQuant: () => void;
+  importFragPipe: () => void;
+  importGenericMatrix: () => void;
+  annotateExperiment: () => void;
+  setLog2Scale: () => void;
+  normalize: () => void;
+  impute: () => void;
+  differentialExpression: () => void;
+  enrichmentAnalysis: () => void;
+  exportEnrichmentInputs: () => void;
+  computeSpcStatus: () => void;
+  showVolcanoPlot: () => void;
+  showHeatmap: () => void;
+  showPcaPlot: () => void;
+  showGroupMeanCorrelation: () => void;
+  showQcDashboard: () => void;
+  showSpcDashboard: () => void;
+  enrichmentCharts: () => void;
+  showAllVisualizations: () => void;
+  shareAnalysisForReview: () => void;
+}
+
+/** Our subgroups/items under the ribbon 'Proteomics' group. Cleared before a (re)build so
+ * repeated calls replace rather than duplicate. 'Import' is ours here too — the decorator
+ * Import lives only in the left-bar main menu, not the ribbon. */
+const DYNAMIC_SECTIONS = ['Import', 'Annotate Experiment...', 'Analyze', 'Visualize', 'Share'];
+
+/**
+ * Is this an analysis table the full Proteomics menu should attach to? Every parser stamps
+ * `proteomics.source`, so its presence is the reliable signal. Plain CSVs and the
+ * sample-level PCA table (which has no source tag) get only the decorator Import.
+ */
+export function isProteomicsTable(df: DG.DataFrame | null | undefined): boolean {
+  return !!df && !!df.getTag('proteomics.source');
+}
+
+/**
+ * Disable reason for sample-level menu items on `df`, or `null` when they're fine.
+ * Re-evaluated by the platform every time the menu opens, so it tracks the live table.
+ * Only a Spectronaut Candidates table is blocked; the per-handler runtime guards stay in
+ * place as the backstop for every other not-ready case.
+ */
+export function sampleLevelDisabledReason(df: DG.DataFrame | null | undefined): string | null {
+  if (df && df.getTag('proteomics.source') === 'spectronaut-candidates') {
+    return 'Not applicable to a Spectronaut Candidates file — it already carries computed ' +
+      'differential expression and has no per-sample intensities. Use Volcano Plot, ' +
+      'Enrichment Analysis or the UniProt panel, or import the matching Spectronaut Report ' +
+      'for sample-level analyses.';
+  }
+  return null;
+}
+
+/**
+ * Build the dynamic analysis groups onto a table view's ribbon, attaching to the Proteomics
+ * group the decorator Import created. Returns `true` if it built (the view is a Proteomics
+ * table), `false` otherwise — the caller uses that to decide whether the view is "done".
+ *
+ * Idempotent: clears its own sections first (never the decorator 'Import') so a rebuild
+ * replaces rather than duplicates.
+ */
+export function buildProteomicsRibbonMenu(view: DG.TableView, h: ProteomicsMenuHandlers): boolean {
+  const df = view.dataFrame;
+  if (!isProteomicsTable(df))
+    return false;
+
+  const root = view.ribbonMenu.group('Proteomics');
+  for (const s of DYNAMIC_SECTIONS) {
+    try { root.remove(s); } catch { /* not present — fine */ }
+  }
+
+  const sampleOnly = {isEnabled: () => sampleLevelDisabledReason(view.dataFrame)};
+
+  // Import — the ribbon's own copy (the decorator Import only reaches the left-bar menu).
+  const imp = root.group('Import');
+  imp.item('Spectronaut Candidates...', h.importSpectronautCandidates);
+  imp.item('Spectronaut Report...', h.importSpectronaut);
+  imp.item('MaxQuant...', h.importMaxQuant);
+  imp.item('FragPipe...', h.importFragPipe);
+  imp.item('Generic Matrix...', h.importGenericMatrix);
+
+  root.item('Annotate Experiment...', h.annotateExperiment, null, sampleOnly);
+
+  const analyze = root.group('Analyze');
+  analyze.item('Set Log2 Scale...', h.setLog2Scale, null, sampleOnly);
+  analyze.item('Normalize...', h.normalize, null, sampleOnly);
+  analyze.item('Impute Missing Values...', h.impute, null, sampleOnly);
+  analyze.item('Differential Expression...', h.differentialExpression, null, sampleOnly);
+  analyze.item('Enrichment Analysis...', h.enrichmentAnalysis);
+  analyze.item('Export Enrichment Inputs...', h.exportEnrichmentInputs);
+  analyze.item('Compute SPC Status', h.computeSpcStatus, null, sampleOnly);
+
+  const viz = root.group('Visualize');
+  viz.item('Volcano Plot...', h.showVolcanoPlot);
+  viz.item('Heatmap...', h.showHeatmap, null, sampleOnly);
+  viz.item('PCA...', h.showPcaPlot, null, sampleOnly);
+  viz.item('Group-Mean Correlation...', h.showGroupMeanCorrelation, null, sampleOnly);
+  viz.item('QC Dashboard...', h.showQcDashboard, null, sampleOnly);
+  viz.item('SPC Dashboard...', h.showSpcDashboard);
+  viz.item('Enrichment Charts...', h.enrichmentCharts);
+  viz.item('Show All Visualizations...', h.showAllVisualizations, null, sampleOnly);
+
+  const share = root.group('Share');
+  share.item('Share Analysis for Review...', h.shareAnalysisForReview);
+  return true;
+}

package/src/package-api.ts

@@ -9,29 +9,151 @@ import * as DG from 'datagrok-api/dg';
 
 export namespace scripts {
   /**
-  [Legacy] Assigns antibody numbering (IMGT/Kabat/Chothia/AHo) using AbNumber
-  */
-  export async function numberAntibodySequencesAbNumber(df: DG.DataFrame , seqCol: DG.Column , scheme: string ): Promise<DG.DataFrame> {
-    return await grok.functions.call('Proteomics:NumberAntibodySequencesAbNumber', { df, seqCol, scheme });
+   * DEqMS peptide-count-weighted differential expression
+   */
+  export async function deqmsDE(exprDf: DG.DataFrame , nGroup1: number , peptideDf: DG.DataFrame , fcThreshold: number , pThreshold: number ): Promise<DG.DataFrame> {
+    return await grok.functions.call('Proteomics:DeqmsDE', { exprDf, nGroup1, peptideDf, fcThreshold, pThreshold });
   }
 
   /**
-  [Legacy] Assigns antibody numbering (IMGT/Kabat/Chothia/AHo) using ANARCI directly
-  */
-  export async function numberAntibodySequencesANARCI(df: DG.DataFrame , seqCol: DG.Column , scheme: string ): Promise<DG.DataFrame> {
-    return await grok.functions.call('Proteomics:NumberAntibodySequencesANARCI', { df, seqCol, scheme });
+   * Differential expression via limma moderated t-test
+   */
+  export async function limmaDE(exprDf: DG.DataFrame , nGroup1: number , fcThreshold: number , pThreshold: number ): Promise<DG.DataFrame> {
+    return await grok.functions.call('Proteomics:LimmaDE', { exprDf, nGroup1, fcThreshold, pThreshold });
   }
 
   /**
-  Assigns antibody numbering (IMGT/Kabat/Chothia/AHo) using AntPack
-  */
-  export async function antpackAntibodyNumbering(df: DG.DataFrame , seqCol: DG.Column , scheme: string ): Promise<DG.DataFrame> {
-    return await grok.functions.call('Proteomics:AntpackAntibodyNumbering', { df, seqCol, scheme });
+   * Variance-stabilizing normalization via vsn
+   */
+  export async function vsnNormalize(exprDf: DG.DataFrame ): Promise<DG.DataFrame> {
+    return await grok.functions.call('Proteomics:VsnNormalize', { exprDf });
   }
 }
 
 export namespace funcs {
-  export async function info(): Promise<void> {
-    return await grok.functions.call('Proteomics:Info', {});
+  export async function initProteomics(): Promise<void> {
+    return await grok.functions.call('Proteomics:InitProteomics', {});
+  }
+
+  export async function buildProteomicsTopMenu(): Promise<void> {
+    return await grok.functions.call('Proteomics:BuildProteomicsTopMenu', {});
+  }
+
+  export async function importSpectronautCandidates(): Promise<void> {
+    return await grok.functions.call('Proteomics:ImportSpectronautCandidates', {});
+  }
+
+  export async function importSpectronaut(): Promise<void> {
+    return await grok.functions.call('Proteomics:ImportSpectronaut', {});
+  }
+
+  export async function importMaxQuant(): Promise<void> {
+    return await grok.functions.call('Proteomics:ImportMaxQuant', {});
+  }
+
+  export async function importFragPipe(): Promise<void> {
+    return await grok.functions.call('Proteomics:ImportFragPipe', {});
+  }
+
+  export async function importGenericMatrix(): Promise<void> {
+    return await grok.functions.call('Proteomics:ImportGenericMatrix', {});
+  }
+
+  export async function annotateExperiment(): Promise<void> {
+    return await grok.functions.call('Proteomics:AnnotateExperiment', {});
+  }
+
+  export async function setLog2Scale(): Promise<void> {
+    return await grok.functions.call('Proteomics:SetLog2Scale', {});
+  }
+
+  export async function normalizeProteomics(): Promise<void> {
+    return await grok.functions.call('Proteomics:NormalizeProteomics', {});
+  }
+
+  export async function imputeMissingValues(): Promise<void> {
+    return await grok.functions.call('Proteomics:ImputeMissingValues', {});
+  }
+
+  export async function differentialExpression(): Promise<void> {
+    return await grok.functions.call('Proteomics:DifferentialExpression', {});
+  }
+
+  export async function computeSpcStatus(): Promise<void> {
+    return await grok.functions.call('Proteomics:ComputeSpcStatus', {});
+  }
+
+  export async function showVolcanoPlot(): Promise<void> {
+    return await grok.functions.call('Proteomics:ShowVolcanoPlot', {});
+  }
+
+  export async function showHeatmap(): Promise<void> {
+    return await grok.functions.call('Proteomics:ShowHeatmap', {});
+  }
+
+  export async function showPcaPlot(): Promise<void> {
+    return await grok.functions.call('Proteomics:ShowPcaPlot', {});
+  }
+
+  export async function showGroupMeanCorrelation(): Promise<void> {
+    return await grok.functions.call('Proteomics:ShowGroupMeanCorrelation', {});
+  }
+
+  export async function showQcDashboard(): Promise<void> {
+    return await grok.functions.call('Proteomics:ShowQcDashboard', {});
+  }
+
+  export async function showSpcDashboard(): Promise<void> {
+    return await grok.functions.call('Proteomics:ShowSpcDashboard', {});
+  }
+
+  export async function showAllVisualizations(): Promise<void> {
+    return await grok.functions.call('Proteomics:ShowAllVisualizations', {});
+  }
+
+  export async function enrichmentAnalysis(): Promise<void> {
+    return await grok.functions.call('Proteomics:EnrichmentAnalysis', {});
+  }
+
+  export async function exportEnrichmentInputs(): Promise<void> {
+    return await grok.functions.call('Proteomics:ExportEnrichmentInputs', {});
+  }
+
+  export async function enrichmentCharts(): Promise<void> {
+    return await grok.functions.call('Proteomics:EnrichmentCharts', {});
+  }
+
+  export async function proteomicsDemo(): Promise<void> {
+    return await grok.functions.call('Proteomics:ProteomicsDemo', {});
+  }
+
+  export async function proteomicsEnrichmentDemo(): Promise<void> {
+    return await grok.functions.call('Proteomics:ProteomicsEnrichmentDemo', {});
+  }
+
+  /**
+   * UniProt protein details
+   * @param {string} proteinId
+   *   semType: Proteomics-ProteinId
+   */
+  export async function uniprotPanelWidget(proteinId: string ): Promise<any> {
+    return await grok.functions.call('Proteomics:UniprotPanelWidget', { proteinId });
+  }
+
+  export async function shareAnalysisForReview(): Promise<void> {
+    return await grok.functions.call('Proteomics:ShareAnalysisForReview', {});
+  }
+
+  /**
+   * Audit context for a shared analysis snapshot
+   * @param {string} proteinId
+   *   semType: Proteomics-ProteinId
+   */
+  export async function publishedAnalysisPanelWidget(proteinId: string ): Promise<any> {
+    return await grok.functions.call('Proteomics:PublishedAnalysisPanelWidget', { proteinId });
+  }
+
+  export async function recoverPublishedProjectsOnStartup(): Promise<void> {
+    return await grok.functions.call('Proteomics:RecoverPublishedProjectsOnStartup', {});
   }
 }

package/src/package-test.ts

@@ -1,20 +1,45 @@
-import { runTests, tests, TestContext , initAutoTests as initTests } from '@datagrok-libraries/test/src/test';
-import * as DG from 'datagrok-api/dg';
-
-export let _package = new DG.Package();
-export { tests };
-
-//name: test
-//input: string category {optional: true}
-//input: string test {optional: true}
-//input: object testContext {optional: true}
-//output: dataframe result
-export async function test(category: string, test: string, testContext: TestContext): Promise<DG.DataFrame> {
-  const data = await runTests({ category, test, testContext });
-  return DG.DataFrame.fromObjects(data)!;
-}
-
-//name: initAutoTests
-export async function initAutoTests() {
-  await initTests(_package, _package.getModule('package-test.js'));
-}
+import * as DG from 'datagrok-api/dg';
+import {runTests, TestContext, tests, initAutoTests as initTests} from '@datagrok-libraries/test/src/test';
+
+import './tests/parsers';
+import './tests/analysis';
+import './tests/generic-parser';
+import './tests/qc-dashboard';
+import './tests/enrichment';
+import './tests/enrichment-export';
+import './tests/enrichment-visualization';
+import './tests/spectronaut-parser';
+import './tests/spectronaut-candidates-parser';
+import './tests/spectronaut-candidates-e2e';
+import './tests/fragpipe-parser';
+import './tests/fragpipe-e2e';
+import './tests/subcellular-location';
+import './tests/organisms';
+import './tests/log2-scale';
+import './tests/volcano';
+import './tests/gene-label-resolver';
+import './tests/smart-pathway-filter';
+import './tests/uniprot-panel';
+import './tests/group-mean-correlation';
+import './tests/publish-spike';
+import './tests/publish-roundtrip';
+import './tests/spc-formula-lines-spike';
+import './tests/spc';
+
+export const _package = new DG.Package();
+export {tests};
+
+//name: test
+//input: string category {optional: true}
+//input: string test {optional: true}
+//input: object testContext {optional: true}
+//output: dataframe result
+export async function test(category: string, test: string, testContext: TestContext): Promise<DG.DataFrame> {
+  const data = await runTests({category, test, testContext});
+  return DG.DataFrame.fromObjects(data)!;
+}
+
+//name: initAutoTests
+export async function initAutoTests() {
+  await initTests(_package, _package.getModule('package-test.js'));
+}

package/src/package.g.ts

@@ -1 +1,162 @@
+import {PackageFunctions} from './package';
 import * as DG from 'datagrok-api/dg';
+
+//tags: init
+//meta.role: init
+export async function initProteomics() : Promise<void> {
+  await PackageFunctions.initProteomics();
+}
+
+//tags: autostart
+//meta.autostartImmediate: true
+export async function buildProteomicsTopMenu() : Promise<void> {
+  await PackageFunctions.buildProteomicsTopMenu();
+}
+
+//top-menu: Proteomics | Import | Spectronaut Candidates...
+export async function importSpectronautCandidates() : Promise<void> {
+  await PackageFunctions.importSpectronautCandidates();
+}
+
+//top-menu: Proteomics | Import | Spectronaut Report...
+export async function importSpectronaut() : Promise<void> {
+  await PackageFunctions.importSpectronaut();
+}
+
+//top-menu: Proteomics | Import | MaxQuant...
+export async function importMaxQuant() : Promise<void> {
+  await PackageFunctions.importMaxQuant();
+}
+
+//top-menu: Proteomics | Import | FragPipe...
+export async function importFragPipe() : Promise<void> {
+  await PackageFunctions.importFragPipe();
+}
+
+//top-menu: Proteomics | Import | Generic Matrix...
+export async function importGenericMatrix() : Promise<void> {
+  await PackageFunctions.importGenericMatrix();
+}
+
+//name: annotateExperiment
+export async function annotateExperiment() : Promise<void> {
+  await PackageFunctions.annotateExperiment();
+}
+
+//name: setLog2Scale
+export async function setLog2Scale() : Promise<void> {
+  await PackageFunctions.setLog2Scale();
+}
+
+//name: normalizeProteomics
+export async function normalizeProteomics() : Promise<void> {
+  await PackageFunctions.normalizeProteomics();
+}
+
+//name: imputeMissingValues
+export async function imputeMissingValues() : Promise<void> {
+  await PackageFunctions.imputeMissingValues();
+}
+
+//name: differentialExpression
+export async function differentialExpression() : Promise<void> {
+  await PackageFunctions.differentialExpression();
+}
+
+//name: computeSpcStatus
+export async function computeSpcStatus() : Promise<void> {
+  await PackageFunctions.computeSpcStatus();
+}
+
+//name: showVolcanoPlot
+export async function showVolcanoPlot() : Promise<void> {
+  await PackageFunctions.showVolcanoPlot();
+}
+
+//name: showHeatmap
+export async function showHeatmap() : Promise<void> {
+  await PackageFunctions.showHeatmap();
+}
+
+//name: showPcaPlot
+export async function showPcaPlot() : Promise<void> {
+  await PackageFunctions.showPcaPlot();
+}
+
+//name: showGroupMeanCorrelation
+export async function showGroupMeanCorrelation() : Promise<void> {
+  await PackageFunctions.showGroupMeanCorrelation();
+}
+
+//name: showQcDashboard
+export async function showQcDashboard() : Promise<void> {
+  await PackageFunctions.showQcDashboard();
+}
+
+//name: showSpcDashboard
+export async function showSpcDashboard() : Promise<void> {
+  await PackageFunctions.showSpcDashboard();
+}
+
+//name: showAllVisualizations
+export async function showAllVisualizations() : Promise<void> {
+  await PackageFunctions.showAllVisualizations();
+}
+
+//name: enrichmentAnalysis
+export async function enrichmentAnalysis() : Promise<void> {
+  await PackageFunctions.enrichmentAnalysis();
+}
+
+//name: exportEnrichmentInputs
+export async function exportEnrichmentInputs() : Promise<void> {
+  await PackageFunctions.exportEnrichmentInputs();
+}
+
+//name: enrichmentCharts
+export async function enrichmentCharts() : Promise<void> {
+  await PackageFunctions.enrichmentCharts();
+}
+
+//name: Proteomics Demo
+//meta.demoPath: Proteomics | Differential Expression
+//meta.isDemoDashboard: true
+export async function proteomicsDemo() : Promise<void> {
+  await PackageFunctions.proteomicsDemo();
+}
+
+//name: Proteomics Enrichment Demo
+//meta.demoPath: Proteomics | Enrichment Analysis
+//meta.isDemoDashboard: true
+export async function proteomicsEnrichmentDemo() : Promise<void> {
+  await PackageFunctions.proteomicsEnrichmentDemo();
+}
+
+//name: Proteomics | UniProt
+//description: UniProt protein details
+//input: string proteinId { semType: Proteomics-ProteinId }
+//output: widget result
+//meta.role: widgets,panel
+export function uniprotPanelWidget(proteinId: string) : any {
+  return PackageFunctions.uniprotPanelWidget(proteinId);
+}
+
+//name: shareAnalysisForReview
+export async function shareAnalysisForReview() : Promise<void> {
+  await PackageFunctions.shareAnalysisForReview();
+}
+
+//name: Proteomics | Shared Analysis
+//description: Audit context for a shared analysis snapshot
+//input: string proteinId { semType: Proteomics-ProteinId }
+//output: widget result
+//meta.role: widgets,panel
+export function publishedAnalysisPanelWidget(proteinId: string) : any {
+  return PackageFunctions.publishedAnalysisPanelWidget(proteinId);
+}
+
+//tags: autostart
+//meta.autostartImmediate: true
+export async function recoverPublishedProjectsOnStartup() : Promise<void> {
+  await PackageFunctions.recoverPublishedProjectsOnStartup();
+}