@datagrok/bio 2.22.1 → 2.22.3

package/src/utils/multiple-sequence-alignment-ui.ts

@@ -1,3 +1,6 @@
+/* eslint-disable max-len */
+/* eslint-disable max-params */
+/* eslint-disable max-lines-per-function */
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
@@ -27,10 +30,15 @@ export async function multipleSequenceAlignmentUI(
     options.pepsea.gapExtend ??= msaDefaultOptions.pepsea.gapExtend;
 
     const table = options.col?.dataFrame ?? grok.shell.t;
+    if (!table) {
+      const errMsg: string = `Multiple Sequence Alignment analysis requires a dataset with a macromolecule column.`;
+      reject(new MsaWarning(ui.divText(errMsg)));
+      return; // Prevents creating the MSA dialog
+    }
+
     const seqCol = options.col ?? table.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
     if (seqCol == null) {
       const errMsg: string = `Multiple Sequence Alignment analysis requires a dataset with a macromolecule column.`;
-      grok.shell.warning(errMsg);
       reject(new MsaWarning(ui.divText(errMsg)));
       return; // Prevents creating the MSA dialog
     }
@@ -50,6 +58,8 @@ export async function multipleSequenceAlignmentUI(
     const gapExtendInput = ui.input.float('Gap extend', {value: options.pepsea.gapExtend});
     gapExtendInput.setTooltip('Gap extension penalty to skip the alignment');
 
+    const onlySelectedRowsInput = ui.input.bool('Selected Rows Only', {value: false});
+
     const msaParamsDiv = ui.inputs([gapOpenInput, gapExtendInput, terminalGapInput]);
     const msaParamsButton = ui.button('Alignment parameters', () => {
       msaParamsDiv.hidden = !msaParamsDiv.hidden;
@@ -80,7 +90,7 @@ export async function multipleSequenceAlignmentUI(
           okBtn.disabled = false;
           performAlignment = await onColInputChange(
             colInput.value, table, seqHelper, pepseaInputRootStyles, kalignInputRootStyles,
-            methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput,
+            methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput, onlySelectedRowsInput
           );
         }, filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE
       } as ColumnInputOptions
@@ -95,6 +105,7 @@ export async function multipleSequenceAlignmentUI(
       .add(methodInput)
       .add(msaParamsDiv)
       .add(msaParamsButton)
+      .add(onlySelectedRowsInput)
       .add(kalignVersionDiv)
       .onOK(async () => { await onDialogOk(colInput, table, performAlignment, resolve, reject); });
     const okBtn = dlg.getButton('OK');
@@ -104,7 +115,7 @@ export async function multipleSequenceAlignmentUI(
     if (options.col) {
       performAlignment = await onColInputChange(
         options.col, table, seqHelper, pepseaInputRootStyles, kalignInputRootStyles,
-        methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput,
+        methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput, onlySelectedRowsInput
       );
       await onDialogOk(colInput, table, performAlignment, resolve, reject);
       return; // Prevents show the dialog
@@ -150,7 +161,7 @@ async function onColInputChange(
   pepseaInputRootStyles: CSSStyleDeclaration[], kalignInputRootStyles: CSSStyleDeclaration[],
   methodInput: DG.InputBase<string | null>, clustersColInput: DG.InputBase<DG.Column<any> | null>,
   gapOpenInput: DG.InputBase<number | null>, gapExtendInput: DG.InputBase<number | null>,
-  terminalGapInput: DG.InputBase<number | null>,
+  terminalGapInput: DG.InputBase<number | null>, selectedRowsOnlyInput: DG.InputBase<boolean>,
 ): Promise<(() => Promise<DG.Column<string> | null>) | undefined> {
   try {
     if (col.semType !== DG.SEMTYPE.MACROMOLECULE)
@@ -167,7 +178,7 @@ async function onColInputChange(
       const potentialColSh = seqHelper.getSeqHandler(col);
       const performCol: DG.Column<string> = potentialColSh.isFasta() ? col :
         potentialColSh.convert(NOTATION.FASTA);
-      return async () => await runKalign(performCol, false, unusedName, clustersColInput.value);
+      return async () => await runKalign(table, performCol, false, unusedName, clustersColInput.value, undefined, undefined, undefined, selectedRowsOnlyInput.value);
     } else if (checkInputColumn(col, col.name, seqHelper, [NOTATION.HELM], [])[0]) {
       // PepSeA branch - Helm notation or separator notation with unknown alphabets
       switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'pepsea');
@@ -175,8 +186,8 @@ async function onColInputChange(
       gapExtendInput.value ??= msaDefaultOptions.pepsea.gapExtend;
 
       return async () => {
-        return runPepsea(col, unusedName, methodInput.value!,
-          gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
+        return runPepsea(table, col, unusedName, methodInput.value!,
+          gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value, undefined, selectedRowsOnlyInput.value);
       };
     } else if (checkInputColumn(col, col.name, seqHelper, [NOTATION.SEPARATOR], [ALPHABET.UN])[0]) {
       //if the column is separator with unknown alphabet, it might be helm. check if it can be converted to helm
@@ -188,8 +199,8 @@ async function onColInputChange(
       // convert to helm and assign alignment function to PepSea
 
       return async () => {
-        return runPepsea(helmCol, unusedName, methodInput.value!,
-          gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
+        return runPepsea(table, helmCol, unusedName, methodInput.value!,
+          gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value, undefined, selectedRowsOnlyInput.value);
       };
     } else {
       gapOpenInput.value = null;

package/src/utils/multiple-sequence-alignment.ts

@@ -1,3 +1,5 @@
+/* eslint-disable max-params */
+/* eslint-disable max-len */
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
@@ -44,8 +46,8 @@ function _stringsToFasta(sequences: string[]): string {
  * @param {number | undefined} terminalGap Terminal gap penalty.
  * @return {Promise<DG.Column>} Aligned sequences.
  */
-export async function runKalign(srcCol: DG.Column<string>, isAligned: boolean = false, unUsedName: string = '',
-  clustersCol: DG.Column | null = null, gapOpen?: number, gapExtend?: number, terminalGap?: number,
+export async function runKalign(table: DG.DataFrame, srcCol: DG.Column<string>, isAligned: boolean = false, unUsedName: string = '',
+  clustersCol: DG.Column | null = null, gapOpen?: number, gapExtend?: number, terminalGap?: number, onlySelected?: boolean
 ): Promise<DG.Column> {
   let sequences: string[] = srcCol.toList();
 
@@ -63,10 +65,21 @@ export async function runKalign(srcCol: DG.Column<string>, isAligned: boolean =
   const clustersColData = clustersCol.getRawData();
   const fastaSequences: string[][] = new Array(clustersColCategories.length);
   const clusterIndexes: number[][] = new Array(clustersColCategories.length);
-  for (let rowIdx = 0; rowIdx < sequencesLength; ++rowIdx) {
-    const clusterCategoryIdx = clustersColData[rowIdx];
-    (fastaSequences[clusterCategoryIdx] ??= []).push(sequences[rowIdx]);
-    (clusterIndexes[clusterCategoryIdx] ??= []).push(rowIdx);
+  if (!onlySelected) {
+    for (let rowIdx = 0; rowIdx < sequencesLength; ++rowIdx) {
+      const clusterCategoryIdx = clustersColData[rowIdx];
+      (fastaSequences[clusterCategoryIdx] ??= []).push(sequences[rowIdx]);
+      (clusterIndexes[clusterCategoryIdx] ??= []).push(rowIdx);
+    }
+  } else {
+    const selection = table.selection;
+    if (selection.length === 0)
+      throw new Error('No selected rows in the table.');
+    for (let rowIdx = -1; (rowIdx = selection.findNext(rowIdx, true)) !== -1;) {
+      const clusterCategoryIdx = clustersColData[rowIdx];
+      (fastaSequences[clusterCategoryIdx] ??= []).push(sequences[rowIdx]);
+      (clusterIndexes[clusterCategoryIdx] ??= []).push(rowIdx);
+    }
   }
   checkForSingleSeqClusters(clusterIndexes, clustersColCategories);
 
@@ -78,6 +91,8 @@ export async function runKalign(srcCol: DG.Column<string>, isAligned: boolean =
 
   for (let clusterIdx = 0; clusterIdx < clustersColCategories.length; ++clusterIdx) {
     const clusterSequences = fastaSequences[clusterIdx];
+    if (!clusterSequences || clusterSequences.length === 0)
+      continue; // skip empty clusters
     const fasta = _stringsToFasta(clusterSequences);
 
     await CLI.fs.writeFile(fastaInputFilename, fasta);
@@ -122,7 +137,7 @@ export async function testMSAEnoughMemory(col: DG.Column<string>): Promise<void>
 
   for (let i = delta; i < sequencesCount; i += delta) {
     try {
-      await runKalign(DG.Column.fromStrings(col.name, col.toList().slice(0, Math.round(i))));
+      await runKalign(col.dataFrame, DG.Column.fromStrings(col.name, col.toList().slice(0, Math.round(i))));
       console.log(`runKalign succeeded on ${i}`);
     } catch (error) {
       console.log(`runKalign failed on ${i} with '${error}'`);

package/src/utils/pepsea.ts

@@ -1,13 +1,10 @@
+/* eslint-disable max-params */
 /* Do not change these import lines to match external modules in webpack configuration */
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {Subject} from 'rxjs';
-
-import {testEvent} from '@datagrok-libraries/utils/src/test';
 import {NOTATION, TAGS as bioTAGS, ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {fetchWrapper} from '@datagrok-libraries/utils/src/fetch-utils';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
 
 import {checkForSingleSeqClusters} from './multiple-sequence-alignment';
@@ -44,9 +41,9 @@ type PepseaBodyUnit = { ID: string, HELM: string };
  * @param {DG.Column} clustersCol - The column containing the clusters of the sequences.
  * @param logger {ILogger} Logger
  */
-export async function runPepsea(srcCol: DG.Column<string>, unUsedName: string,
+export async function runPepsea(table: DG.DataFrame, srcCol: DG.Column<string>, unUsedName: string,
   method: typeof pepseaMethods[number] = 'ginsi', gapOpen: number = 1.53, gapExtend: number = 0.0,
-  clustersCol: DG.Column<string | number> | null = null, logger?: ILogger
+  clustersCol: DG.Column<string | number> | null = null, logger?: ILogger, onlySelected: boolean = false
 ): Promise<DG.Column<string>> {
   const pepseaContainer = await Pepsea.getDockerContainer();
   const peptideCount = srcCol.length;
@@ -60,23 +57,42 @@ export async function runPepsea(srcCol: DG.Column<string>, unUsedName: string,
   const clusterIndexes: number[][] = new Array(clustersColCategories.length);
 
   // Grouping data by clusters
-  for (let rowIndex = 0; rowIndex < peptideCount; ++rowIndex) {
-    const clusterCategoryIdx = clustersColData[rowIndex];
-    const cluster = clustersColCategories[clusterCategoryIdx];
-    if (cluster === '')
-      continue;
-
-    const clusterId = clustersColCategories.indexOf(cluster);
-    const helmSeq = srcCol.get(rowIndex);
-    if (helmSeq) {
-      (bodies[clusterId] ??= []).push({ID: rowIndex.toString(), HELM: helmSeq});
-      (clusterIndexes[clusterCategoryIdx] ??= []).push(rowIndex);
+  if (!onlySelected) {
+    for (let rowIndex = 0; rowIndex < peptideCount; ++rowIndex) {
+      const clusterCategoryIdx = clustersColData[rowIndex];
+      const cluster = clustersColCategories[clusterCategoryIdx];
+      if (!cluster)
+        continue;
+
+      const clusterId = clusterCategoryIdx;
+      const helmSeq = srcCol.get(rowIndex);
+      if (helmSeq) {
+        (bodies[clusterId] ??= []).push({ID: rowIndex.toString(), HELM: helmSeq});
+        (clusterIndexes[clusterCategoryIdx] ??= []).push(rowIndex);
+      }
+    }
+  } else {
+    const selection = table.selection;
+    for (let rowIndex = -1; (rowIndex = selection.findNext(rowIndex, true)) !== -1;) {
+      const clusterCategoryIdx = clustersColData[rowIndex];
+      const cluster = clustersColCategories[clusterCategoryIdx];
+      if (!cluster)
+        continue;
+
+      const clusterId = clusterCategoryIdx;
+      const helmSeq = srcCol.get(rowIndex);
+      if (helmSeq) {
+        (bodies[clusterId] ??= []).push({ID: rowIndex.toString(), HELM: helmSeq});
+        (clusterIndexes[clusterCategoryIdx] ??= []).push(rowIndex);
+      }
     }
   }
   checkForSingleSeqClusters(clusterIndexes, clustersColCategories);
 
-  const alignedSequences: string[] = new Array(peptideCount);
+  const alignedSequences: string[] = new Array(peptideCount).fill(null);
   for (const body of bodies) { // getting aligned sequences for each cluster
+    if (!body || body.length === 0)
+      continue;
     const alignedObject = await requestAlignedObjects(pepseaContainer.id, body, method, gapOpen, gapExtend, logger);
     const alignments = alignedObject.Alignment;
 

package/src/widgets/representations.ts

@@ -6,11 +6,9 @@ import * as DG from 'datagrok-api/dg';
 import {TAGS as mmcrTAGS} from '@datagrok-libraries/bio/src/utils/cell-renderer';
 
 import {MmcrTemps, rendererSettingsChangedState} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
-import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
-import {getMolfilesFromSingleSeq} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
 import {_package} from '../package';
-
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 /**
  * @export
@@ -107,67 +105,42 @@ export function getMacromoleculeColumnPropertyPanel(col: DG.Column): DG.Widget {
     tooltipText: 'When on, all sequences get rendered in the "diff" mode'
   });
 
-  const sequenceConfigInputs = ui.inputs([
+  const shouldShowMultilineToggle = (): boolean => {
+    const units = col.meta.units;
+
+    // Don't show for formats that have their own complex renderers (like Helm).
+    if (units === NOTATION.HELM || units === NOTATION.CUSTOM)
+      return false;
+
+    // For all other cases, including 'UN' (non-canonical), 'fasta', and 'separator' show the multiline toggle.
+    return true;
+  };
+
+  let renderMultilineInput = null;
+  if (shouldShowMultilineToggle()) {
+    renderMultilineInput = ui.input.bool('Multiline Rendering', {
+      value: col.getTag('renderMultiline') === 'true',
+      onValueChanged: (value) => {
+        col.tags['renderMultiline'] = value ? 'true' : 'false';
+        col.dataFrame.fireValuesChanged();
+      },
+      tooltipText: 'Render sequences across multiple lines when they exceed cell width'
+    });
+  }
+
+  const inputsArray = [
     fontSizeInput,
     maxMonomerLengthInput,
     gapLengthInput,
     referenceSequenceInput,
     colorCodeInput,
     compareWithCurrentInput,
-  ]);
+  ];
 
-  return new DG.Widget(sequenceConfigInputs);
-}
+  if (renderMultilineInput)
+    inputsArray.push(renderMultilineInput);
 
-/**
- * 3D representation widget of macromolecule.
- *
- * @export
- * @param {DG.Cell} macroMolecule macromolecule cell.
- * @param {any[]} monomersLibObject
- * @param {ISeqHelper} seqHelper
- * @return {Promise<DG.Widget>} Widget.
- */
-export async function representationsWidget(
-  macroMolecule: DG.Cell, monomersLibObject: any[], seqHelper: ISeqHelper
-): Promise<DG.Widget> {
-  const pi = DG.TaskBarProgressIndicator.create('Creating 3D view');
-
-  let widgetHost;
-  let molBlock3D = '';
-  try {
-    try {
-      const _atomicCodes = getMolfilesFromSingleSeq(macroMolecule, monomersLibObject, seqHelper);
-      const result = '';//await getMacroMol(atomicCodes!);
-      const molBlock2D = result[0];
-      molBlock3D = (await grok.functions.call('Bio:Embed', {molBlock2D})) as unknown as string;
-    } catch (e) {
-      console.warn(e);
-    }
-
-    try {
-      molBlock3D = molBlock3D.replaceAll('\\n', '\n');
-      const stringBlob = new Blob([molBlock3D], {type: 'text/plain'});
-      const nglHost = ui.div([], {classes: 'd4-ngl-viewer', id: 'ngl-3d-host'});
-
-      //@ts-ignore
-      const stage = new NGL.Stage(nglHost, {backgroundColor: 'white'});
-      //@ts-ignore
-      stage.loadFile(stringBlob, {ext: 'sdf'}).then(function(comp: NGL.StructureComponent) {
-        stage.setSize(300, 300);
-        comp.addRepresentation('ball+stick');
-        comp.autoView();
-      });
-      const sketch = grok.chem.svgMol(molBlock3D);
-      const panel = ui.divH([sketch]);
-
-      widgetHost = ui.div([panel, nglHost]);
-    } catch (e) {
-      widgetHost = ui.divText('Couldn\'t get peptide structure');
-    }
-  } catch (e) {
-    widgetHost = ui.divText('Couldn\'t get peptide structure');
-  }
-  pi.close();
-  return new DG.Widget(widgetHost);
+
+  const sequenceConfigInputs = ui.inputs(inputsArray);
+  return new DG.Widget(sequenceConfigInputs);
 }