@datagrok/peptides 0.8.5 → 0.8.9

package/package.json

@@ -1,18 +1,16 @@
 {
 	"name": "@datagrok/peptides",
-	"version": "0.8.5",
+	"version": "0.8.9",
 	"description": "",
 	"dependencies": {
 		"@biowasm/aioli": ">=2.4.0",
 		"@datagrok-libraries/bio": ">=0.0.4",
-		"@datagrok-libraries/ml": ">=0.0.10",
+		"@datagrok-libraries/ml": ">=0.0.14",
 		"@datagrok-libraries/statistics": ">=0.1.5",
-		"@datagrok-libraries/utils": ">=0.0.18",
-		"@types/d3": "^7.0.0",
-		"@types/jquery": "^3.5.6",
+		"@datagrok-libraries/utils": ">=0.0.22",
 		"cash-dom": "latest",
 		"d3": "latest",
-		"datagrok-api": ">=0.104.0",
+		"datagrok-api": ">=0.123.0",
 		"dayjs": "latest",
 		"file-loader": "^6.2.0",
 		"jstat": "^1.9.5",
@@ -20,20 +18,20 @@
 		"rxjs": "^6.5.5"
 	},
 	"devDependencies": {
-		"@typescript-eslint/eslint-plugin": "^4.29.1",
-		"@typescript-eslint/parser": "^4.29.1",
+		"@types/d3": "^7.0.0",
+		"@types/jquery": "^3.5.6",
+		"@typescript-eslint/eslint-plugin": "latest",
+		"@typescript-eslint/parser": "latest",
 		"css-loader": "^5.2.4",
-		"eslint": "^7.32.0",
-		"eslint-config-google": "^0.14.0",
+		"eslint": "latest",
+		"eslint-config-google": "latest",
 		"style-loader": "^2.0.0",
-		"ts-loader": "^9.2.5",
-		"typescript": "^4.4.4",
+		"ts-loader": "latest",
+		"typescript": "latest",
 		"webpack": "latest",
 		"webpack-cli": "latest"
 	},
 	"sources": [
-		"files/aligned.csv",
-		"files/aligned_2.csv",
 		"common/ngl_viewer/ngl.js"
 	],
 	"scripts": {

package/setup.cmd

@@ -0,0 +1,18 @@
+call npm unlink datagrok-api
+call npm unlink @datagrok-libraries/utils
+call npm unlink @datagrok-libraries/ml
+cd ../../js-api
+call npm install
+call npm link
+cd ../libraries/utils
+call npm install
+call npm link
+call npm link datagrok-api
+cd ../../libraries/ml
+call npm install
+call npm link
+call npm link @datagrok-libraries/utils
+cd ../../packages/Peptides
+call npm install
+call npm link datagrok-api @datagrok-libraries/utils @datagrok-libraries/ml
+webpack

package/setup.sh

@@ -0,0 +1,15 @@
+npm unlink datagrok-api
+npm unlink @datagrok-libraries/utils
+npm unlink @datagrok-libraries/ml
+cd ../../js-api
+npm install
+npm link
+cd ../libraries/utils
+npm install
+npm link
+cd ../../libraries/ml
+npm install
+npm link datagrok-api @datagrok-libraries/utils
+cd ../../packages/Peptides
+npm install
+npm link datagrok-api @datagrok-libraries/utils @datagrok-libraries/ml 

package/src/describe.ts

@@ -1,10 +1,12 @@
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import {splitAlignedPeptides} from './utils/split-aligned';
+// import {splitAlignedPeptides} from './utils/split-aligned';
 import {tTest} from '@datagrok-libraries/statistics/src/tests';
 import {fdrcorrection} from '@datagrok-libraries/statistics/src/multiple-tests';
+import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
 import {ChemPalette} from './utils/chem-palette';
 import {setAARRenderer} from './utils/cell-renderer';
+import {PeptidesController} from './peptides';
 
 const cp = new ChemPalette('grok');
 
@@ -53,80 +55,72 @@ const groupDescription: {[key: string]: {'description': string, 'aminoAcids': st
   }
 }*/
 
-function joinDataFrames(
-  activityColumnScaled: string,
-  df: DG.DataFrame,
-  positionColumns: string[],
-  splitSeqDf: DG.DataFrame,
-  activityColumn: string,
-) {
-  if (df.col(activityColumnScaled)) {
-    df.columns.remove(activityColumnScaled);
-  }
+function joinDataFrames(df: DG.DataFrame, positionColumns: string[], splitSeqDf: DG.DataFrame, activityColumn: string) {
+  // if (df.col(activityColumnScaled))
+  //   (df.columns as DG.ColumnList).remove(activityColumnScaled);
+
 
   //FIXME: this column usually duplicates, so remove it then
-  if (df.col(`${activityColumnScaled} (2)`)) {
-    df.columns.remove(`${activityColumnScaled} (2)`);
-  }
+  // if (df.col(`${activityColumnScaled} (2)`))
+  //   (df.columns as DG.ColumnList).remove(`${activityColumnScaled} (2)`);
+
 
   // append splitSeqDf columns to source table and make sure columns are not added more than once
-  const dfColsSet = new Set(df.columns.names());
+  const dfColsSet = new Set((df.columns as DG.ColumnList).names());
   if (!positionColumns.every((col: string) => dfColsSet.has(col))) {
-    df.join(splitSeqDf, [activityColumn], [activityColumn], df.columns.names(), positionColumns, 'inner', true);
+    df.join(
+      splitSeqDf, [activityColumn], [activityColumn], (df.columns as DG.ColumnList).names(), positionColumns, 'inner',
+      true);
   }
 }
 
 function sortSourceGrid(sourceGrid: DG.Grid) {
   if (sourceGrid) {
-    const colNames:string[] = [];
-    for (let i = 0; i < sourceGrid.columns.length; i++) {
-      colNames.push(sourceGrid.columns.byIndex(i)!.name);
-    }
+    const colNames: DG.GridColumn[] = [];
+    for (let i = 1; i < sourceGrid.columns.length; i++)
+      colNames.push(sourceGrid.columns.byIndex(i)!);
+
     colNames.sort((a, b)=>{
-      if (sourceGrid.columns.byName(a)?.column?.semType == 'aminoAcids') {
-        if (sourceGrid.columns.byName(b)?.column?.semType == 'aminoAcids') {
+      if (a.column!.semType == 'aminoAcids') {
+        if (b.column!.semType == 'aminoAcids')
           return 0;
-        }
         return -1;
       }
-      if (sourceGrid.columns.byName(b)?.column?.semType == 'aminoAcids') {
+      if (b.column!.semType == 'aminoAcids')
         return 1;
-      }
       return 0;
     });
-    sourceGrid?.columns.setOrder(colNames);
+    sourceGrid.columns.setOrder(colNames.map((v) => v.name));
   }
 }
 
-async function scaleActivity(
-  activityScaling: string,
-  activityColumn: string,
-  activityColumnScaled: string,
-  sourceGrid: DG.Grid,
-  splitSeqDf: DG.DataFrame,
-) {
-  const df = sourceGrid.dataFrame!;
-  switch (activityScaling) {
-  case 'lg':
-    await df.columns.addNewCalculated(activityColumnScaled, 'Log10(${' + activityColumn + '})');
-    splitSeqDf.columns.add(df.getCol(activityColumnScaled));
-    sourceGrid.col(activityColumnScaled)!.name = `Log10(${activityColumn})`;
-    sourceGrid.columns.setOrder([`Log10(${activityColumn})`]);
-    break;
-  case '-lg':
-    await df.columns.addNewCalculated(activityColumnScaled, '-1*Log10(${' + activityColumn + '})');
-    splitSeqDf.columns.add(df.getCol(activityColumnScaled));
-    sourceGrid.col(activityColumnScaled)!.name = `-Log10(${activityColumn})`;
-    sourceGrid.columns.setOrder([`-Log10(${activityColumn})`]);
-    break;
-  default:
-    await df.columns.addNewCalculated(activityColumnScaled, '${' + activityColumn + '}');
-    splitSeqDf.columns.add(df.getCol(activityColumnScaled));
-    sourceGrid.col(activityColumnScaled)!.name = `${activityColumn}`;
-    sourceGrid.columns.setOrder([`${activityColumn}`]);
-    break;
-  }
-}
+// export async function 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];
+// }
 
 async function calculateStatistics(
   matrixDf: DG.DataFrame,
@@ -135,7 +129,7 @@ async function calculateStatistics(
   activityColumnScaled: string,
   peptidesCount: number,
   splitSeqDf: DG.DataFrame,
-  groupMapping: {[key: string]: string},
+  groupMapping: StringDictionary,
 ) {
   matrixDf = matrixDf.groupBy([positionColName, aminoAcidResidue])
     .add('count', activityColumnScaled, 'Count')
@@ -147,12 +141,12 @@ async function calculateStatistics(
   matrixDf = matrixDf.clone(matrixDf.filter);
 
   // calculate additional stats
-  await matrixDf.columns.addNewCalculated('Ratio', '${count}/'.concat(`${peptidesCount}`));
+  await (matrixDf.columns as DG.ColumnList).addNewCalculated('Ratio', '${count}/'.concat(`${peptidesCount}`));
 
   //calculate p-values based on t-test
   let pvalues: Float32Array = new Float32Array(matrixDf.rowCount).fill(1);
-  const mdCol: DG.Column = matrixDf.columns.addNewFloat('Mean difference');
-  const pValCol: DG.Column = matrixDf.columns.addNewFloat('pValue');
+  const mdCol: DG.Column = (matrixDf.columns as DG.ColumnList).addNewFloat('Mean difference');
+  const pValCol: DG.Column = (matrixDf.columns as DG.ColumnList).addNewFloat('pValue');
   for (let i = 0; i < matrixDf.rowCount; i++) {
     const position = matrixDf.get(positionColName, i);
     const aar = matrixDf.get(aminoAcidResidue, i);
@@ -180,13 +174,13 @@ async function calculateStatistics(
     pvalues[i] = pvalue;
   }
 
-  if (true) {
+  if (true)
     pvalues = fdrcorrection(pvalues)[1];
-  }
 
-  for (let i = 0; i < pvalues.length; ++i) {
+
+  for (let i = 0; i < pvalues.length; ++i)
     pValCol.set(i, pvalues[i]);
-  }
+
 
   return matrixDf.clone();
 }
@@ -195,9 +189,9 @@ async function setCategoryOrder(
   twoColorMode: boolean, statsDf: DG.DataFrame, aminoAcidResidue: string, matrixDf: DG.DataFrame,
 ) {
   const sortArgument = twoColorMode ? 'Absolute Mean difference' : 'Mean difference';
-  if (twoColorMode) {
-    await statsDf.columns.addNewCalculated('Absolute Mean difference', 'Abs(${Mean difference})');
-  }
+  if (twoColorMode)
+    await (statsDf.columns as DG.ColumnList).addNewCalculated('Absolute Mean difference', 'Abs(${Mean difference})');
+
   const aarWeightsDf = statsDf.groupBy([aminoAcidResidue]).sum(sortArgument, 'weight').aggregate();
   const aarList = aarWeightsDf.getCol(aminoAcidResidue).toList();
   const getWeight = (aar: string) => aarWeightsDf
@@ -256,28 +250,21 @@ function createGrids(
   sarVGrid.col('pValue')!.name = 'P-Value';
 
   if (!grouping) {
-    let tempCol = matrixDf.columns.byName(aminoAcidResidue);
-    if (tempCol) {
+    let tempCol = (matrixDf.columns as DG.ColumnList).byName(aminoAcidResidue);
+    if (tempCol)
       setAARRenderer(tempCol, sarGrid);
-    }
-    tempCol = sequenceDf.columns.byName(aminoAcidResidue);
-    if (tempCol) {
+
+    tempCol = (sequenceDf.columns as DG.ColumnList).byName(aminoAcidResidue);
+    if (tempCol)
       setAARRenderer(tempCol, sarGrid);
-    }
   }
 
   return [sarGrid, sarVGrid];
 }
 
 function setCellRendererFunc(
-  renderColNames: string[],
-  positionColName: string,
-  aminoAcidResidue: string,
-  statsDf: DG.DataFrame,
-  twoColorMode: boolean,
-  sarGrid: DG.Grid,
-  sarVGrid: DG.Grid,
-) {
+    renderColNames: string[], positionColName: string, aminoAcidResidue: string, statsDf: DG.DataFrame,
+    twoColorMode: boolean, sarGrid: DG.Grid, sarVGrid: DG.Grid) {
   const mdCol = statsDf.getCol('Mean difference');
   const cellRendererFunc = function(args: DG.GridCellRenderArgs) {
     args.g.save();
@@ -308,15 +295,15 @@ function setCellRendererFunc(
 
         let coef;
         const variant = args.cell.cell.value < 0;
-        if (pVal < 0.01) {
+        if (pVal < 0.01)
           coef = variant && twoColorMode ? '#FF7900' : '#299617';
-        } else if (pVal < 0.05) {
+        else if (pVal < 0.05)
           coef = variant && twoColorMode ? '#FFA500' : '#32CD32';
-        } else if (pVal < 0.1) {
+        else if (pVal < 0.1)
           coef = variant && twoColorMode ? '#FBCEB1' : '#98FF98';
-        } else {
+        else
           coef = DG.Color.toHtml(DG.Color.lightLightGray);
-        }
+
 
         const chooseMin = () => twoColorMode ? 0 : mdCol.min;
         const chooseMax = () => twoColorMode ? Math.max(Math.abs(mdCol.min), mdCol.max) : mdCol.max;
@@ -330,12 +317,8 @@ function setCellRendererFunc(
         args.g.beginPath();
         args.g.fillStyle = coef;
         args.g.arc(
-          args.bounds.x + args.bounds.width / 2,
-          args.bounds.y + args.bounds.height / 2,
-          radius < 3 ? 3 : radius,
-          0,
-          Math.PI * 2,
-          true,
+          args.bounds.x + args.bounds.width / 2, args.bounds.y + args.bounds.height / 2, radius < 3 ? 3 : radius, 0,
+          Math.PI * 2, true,
         );
         args.g.closePath();
 
@@ -350,27 +333,15 @@ function setCellRendererFunc(
 }
 
 function setTooltipFunc(
-  renderColNames: string[],
-  statsDf: DG.DataFrame,
-  aminoAcidResidue: string,
-  positionColName: string,
-  peptidesCount: number,
-  grouping: boolean,
-  sarGrid: DG.Grid,
-  sarVGrid: DG.Grid,
-) {
-  const onCellTooltipFunc = function(cell: DG.GridCell, x: number, y: number) {
+    renderColNames: string[], statsDf: DG.DataFrame, aminoAcidResidue: string, positionColName: string,
+    peptidesCount: number, grouping: boolean, sarGrid: DG.Grid, sarVGrid: DG.Grid) {
+  const onCellTooltipFunc = async function(cell: DG.GridCell, x: number, y: number) {
     if (
-      !cell.isRowHeader &&
-      !cell.isColHeader &&
-      cell.tableColumn !== null &&
-      cell.cell.value !== null &&
-      cell.tableRowIndex !== null &&
-      renderColNames.indexOf(cell.tableColumn.name) !== -1
-    ) {
+        !cell.isRowHeader && !cell.isColHeader && cell.tableColumn !== null && cell.cell.value !== null &&
+        cell.tableRowIndex !== null && renderColNames.indexOf(cell.tableColumn.name) !== -1) {
       const tooltipMap: { [index: string]: string } = {};
 
-      for (const col of statsDf.columns.names()) {
+      for (const col of (statsDf.columns as DG.ColumnList).names()) {
         if (col !== aminoAcidResidue && col !== positionColName) {
           const currentPosition = cell.tableColumn.name !== 'Mean difference' ?
             cell.tableColumn.name : cell.grid.table.get(positionColName, cell.tableRowIndex);
@@ -380,11 +351,11 @@ function setTooltipFunc(
           const textNum = statsDf.groupBy([col]).where(query).aggregate().get(col, 0);
           let text = `${col === 'Count' ? textNum : textNum.toFixed(5)}`;
 
-          if (col === 'Count') {
+          if (col === 'Count')
             text += ` / ${peptidesCount}`;
-          } else if (col === 'pValue') {
+          else if (col === 'pValue')
             text = parseFloat(text) !== 0 ? text : '<0.01';
-          }
+
 
           tooltipMap[col === 'pValue' ? 'p-value' : col] = text;
         }
@@ -403,9 +374,8 @@ function setTooltipFunc(
         const currentGroup = groupDescription[cell.cell.value];
         const divText = ui.divText('Amino Acids in this group: ' + currentGroup['aminoAcids'].join(', '));
         ui.tooltip.show(ui.divV([ui.h3(currentGroup['description']), divText]), x, y);
-      } else {
-        cp.showTooltip(cell, x, y);
-      }
+      } else
+        await cp.showTooltip(cell, x, y);
     }
     return true;
   };
@@ -416,7 +386,6 @@ function setTooltipFunc(
 function postProcessGrids(
   sourceGrid: DG.Grid,
   invalidIndexes: number[],
-  matrixDf: DG.DataFrame,
   grouping: boolean,
   aminoAcidResidue: string,
   sarGrid: DG.Grid,
@@ -424,13 +393,23 @@ function postProcessGrids(
 ) {
   sourceGrid.onCellPrepare((cell: DG.GridCell) => {
     const currentRowIndex = cell.tableRowIndex;
-    if (currentRowIndex && invalidIndexes.includes(currentRowIndex) && !cell.isRowHeader) {
+    if (currentRowIndex && invalidIndexes.includes(currentRowIndex) && !cell.isRowHeader)
       cell.style.backColor = DG.Color.lightLightGray;
-    }
   });
 
-  for (const col of matrixDf.columns.names()) {
-    sarGrid.col(col)!.width = sarGrid.props.rowHeight;
+  const mdCol: DG.GridColumn = sarVGrid.col('Mean difference')!;
+  mdCol.name = 'Diff';
+
+  for (const grid of [sarGrid, sarVGrid]) {
+    grid.props.rowHeight = 20;
+    grid.columns.rowHeader!.width = 20;
+    for (let i = 0; i < grid.columns.length; ++i) {
+      const col = grid.columns.byIndex(i)!;
+      if (grid == sarVGrid && col.name !== 'Diff' && col.name !== 'AAR')
+        col.width = 45;
+      else
+        col.width = grid.props.rowHeight;
+    }
   }
 
   if (grouping) {
@@ -450,33 +429,49 @@ export async function describe(
   twoColorMode: boolean,
   initialBitset: DG.BitSet | null,
   grouping: boolean,
-): Promise<[DG.Grid, DG.Grid, DG.DataFrame, {[key: string]: string}]> {
+): Promise<[DG.Grid, DG.Grid, DG.DataFrame, StringDictionary]> {
   //Split the aligned sequence into separate AARs
   let splitSeqDf: DG.DataFrame | undefined;
   let invalidIndexes: number[];
-  const col: DG.Column = df.columns.bySemType('alignedSequence');
-  [splitSeqDf, invalidIndexes] = splitAlignedPeptides(col);
+  const col: DG.Column = (df.columns as DG.ColumnList).bySemType('alignedSequence')!;
+  [splitSeqDf, invalidIndexes] = PeptidesController.splitAlignedPeptides(col);
   splitSeqDf.name = 'Split sequence';
 
-  const positionColumns = splitSeqDf.columns.names();
+  const positionColumns = (splitSeqDf.columns as DG.ColumnList).names();
   const activityColumnScaled = `${activityColumn}Scaled`;
-  const renderColNames: string[] = splitSeqDf.columns.names();
-  const positionColName = 'Position';
+  const renderColNames: string[] = (splitSeqDf.columns as DG.ColumnList).names();
+  const positionColName = 'Pos';
   const aminoAcidResidue = 'AAR';
 
-  splitSeqDf.columns.add(df.getCol(activityColumn));
+  (splitSeqDf.columns as DG.ColumnList).add(df.getCol(activityColumn));
 
-  joinDataFrames(activityColumnScaled, df, positionColumns, splitSeqDf, activityColumn);
+  joinDataFrames(df, positionColumns, splitSeqDf, activityColumn);
 
-  for (const col of df.columns) {
-    if (splitSeqDf.col(col.name) && col.name != activityColumn) {
+  for (const col of (df.columns as DG.ColumnList)) {
+    if (splitSeqDf.col(col.name) && col.name != activityColumn)
       setAARRenderer(col, sourceGrid);
-    }
   }
 
   sortSourceGrid(sourceGrid);
 
-  await scaleActivity(activityScaling, activityColumn, activityColumnScaled, sourceGrid, splitSeqDf);
+  const [scaledDf, newColName] = await PeptidesController.scaleActivity(
+    activityScaling, activityColumn, activityColumnScaled, df);
+  //TODO: make another func
+  const scaledCol = scaledDf.getCol(activityColumnScaled);
+  const oldScaledCol = df.getCol(activityColumnScaled);
+  const oldScaledColGridName = oldScaledCol.temp['gridName'];
+  const oldScaledGridCol = sourceGrid.col(oldScaledColGridName);
+
+  (splitSeqDf.columns as DG.ColumnList).add(scaledCol);
+  (df.columns as DG.ColumnList).replace(oldScaledCol, scaledCol);
+  if (newColName === activityColumn)
+    sourceGrid.col(activityColumn)!.name = `~${activityColumn}`;
+  if (oldScaledGridCol !== null) {
+    oldScaledGridCol.name = newColName;
+    oldScaledGridCol.visible = true;
+  }
+  sourceGrid.columns.setOrder([newColName]);
+
   splitSeqDf = splitSeqDf.clone(initialBitset);
 
   //unpivot a table and handle duplicates
@@ -489,15 +484,15 @@ export async function describe(
   let matrixDf = splitSeqDf.unpivot([activityColumnScaled], positionColumns, positionColName, aminoAcidResidue);
 
   //TODO: move to chem palette
-  let groupMapping: {[key: string]: string} = {};
+  let groupMapping: StringDictionary = {};
   if (grouping) {
     groupMapping = aarGroups;
     const aarCol = matrixDf.getCol(aminoAcidResidue);
     aarCol.init((index) => groupMapping[aarCol.get(index)[0]] ?? '-');
     aarCol.compact();
-  } else {
+  } else
     Object.keys(aarGroups).forEach((value) => groupMapping[value] = value);
-  }
+
 
   //statistics for specific AAR at a specific position
   const statsDf = await calculateStatistics(
@@ -532,7 +527,7 @@ export async function describe(
     renderColNames, statsDf, aminoAcidResidue, positionColName, peptidesCount, grouping, sarGrid, sarVGrid,
   );
 
-  postProcessGrids(sourceGrid, invalidIndexes, matrixDf, grouping, aminoAcidResidue, sarGrid, sarVGrid);
+  postProcessGrids(sourceGrid, invalidIndexes, grouping, aminoAcidResidue, sarGrid, sarVGrid);
 
   //TODO: return class instead
   return [sarGrid, sarVGrid, statsDf, groupMapping];