@datagrok/bio 2.4.25 → 2.4.28

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.4.25",
+  "version": "2.4.28",
   "description": "Bioinformatics support (import/export of sequences, conversion, visualization, analysis). [See more](https://github.com/datagrok-ai/public/blob/master/packages/Bio/README.md) for details.",
   "repository": {
     "type": "git",

package/scripts/sequence_generator.py

@@ -151,8 +151,8 @@ def generate_sequences(
         motif_length = mean_range(average_motif_length, dispersion)
 
         # sys.stderr.write(f"Cluster {n_cluster:2} motif template: {motif_notation(motif_template)}\n")
-        total_length = mean_range(average_random_length * 2, args.dispersion) + motif_length
-        prefix_length = mean_range(average_random_length, args.dispersion // 2)
+        total_length = mean_range(average_random_length * 2, dispersion) + motif_length
+        prefix_length = mean_range(average_random_length, dispersion // 2)
         suffix_length = total_length - motif_length - prefix_length
         sys.stderr.write(f"Generating sequences for cluster {n_cluster}\n")
         for n_seq, seq, activity, is_cliff in generate_cluster(

package/src/demo/bio03-atomic-level.ts

@@ -9,9 +9,10 @@ import {handleError} from './utils';
 import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
 import {delay} from '@datagrok-libraries/utils/src/test';
 
-const dataFn: string = 'samples/sample_FASTA.csv';
-
 export async function demoBio03UI(): Promise<void> {
+  const dataFn: string = 'samples/sample_HELM.csv';
+  const seqColName = 'HELM';
+
   let df: DG.DataFrame;
   let view: DG.TableView;
   let dlg: DG.Dialog;
@@ -29,21 +30,21 @@ export async function demoBio03UI(): Promise<void> {
         view = grok.shell.addTableView(df);
         for (let colI: number = 0; colI < view.grid.columns.length; colI++) {
           const gCol: DG.GridColumn = view.grid.columns.byIndex(colI)!;
-          if (!(['Sequence', 'Activity'].includes(gCol.name))) gCol.visible = false;
+          if (!([seqColName, 'Activity'].includes(gCol.name))) gCol.visible = false;
         }
       }, {
         description: `Load dataset with macromolecules of 'fasta' notation, 'PT' alphabet (protein, aminoacids).`,
         delay: 2000,
       })
       .step('To atomic level', async () => {
-        const seqCol = df.getCol('Sequence');
+        const seqCol = df.getCol(seqColName);
         await toAtomicLevel(df, seqCol);
       }, {
         description: 'Get atomic level structures of Macromolecules.',
         delay: 2000,
       })
       .step('Sketcher', async () => {
-        const molColName: string = 'molfile(Sequence)';
+        const molColName: string = `molfile(${seqColName})`;
         df.currentCell = df.cell(1, molColName);
         const mol: string = df.currentCell.value;
 

package/src/demo/bio05-helm-msa-sequence-space.ts

@@ -61,6 +61,7 @@ export async function demoBio05UI(): Promise<void> {
       .step('Analyse sequence composition', async () => {
         wlViewer = await df.plot.fromType('WebLogo', {
           sequenceColumnName: msaHelmColName,
+          positionWidth: 40,
           maxHeight: 50,
         }) as DG.Viewer & IWebLogoViewer;
         view.dockManager.dock(wlViewer, DG.DOCK_TYPE.DOWN, null, 'Composition analysis', 0.2);

package/src/package.ts

@@ -506,16 +506,17 @@ export async function sdfToJsonLib(table: DG.DataFrame) {
   const jsonMonomerLibrary = createJsonMonomerLibFromSdf(table);
 }
 
-//name: Representations
-//tags: panel, widgets
-//input: cell macroMolecule {semType: Macromolecule}
-//output: widget result
-export async function peptideMolecule(macroMolecule: DG.Cell): Promise<DG.Widget> {
-  const monomersLibFile = await _package.files.readAsText(HELM_CORE_LIB_FILENAME);
-  const monomersLibObject: any[] = JSON.parse(monomersLibFile);
-
-  return representationsWidget(macroMolecule, monomersLibObject);
-}
+// 2023-05-17 Representations does not work at BioIT
+// //name: Representations
+// //tags: panel, widgets
+// //input: cell macroMolecule {semType: Macromolecule}
+// //output: widget result
+// export async function peptideMolecule(macroMolecule: DG.Cell): Promise<DG.Widget> {
+//   const monomersLibFile = await _package.files.readAsText(HELM_CORE_LIB_FILENAME);
+//   const monomersLibObject: any[] = JSON.parse(monomersLibFile);
+//
+//   return representationsWidget(macroMolecule, monomersLibObject);
+// }
 
 //name: importFasta
 //description: Opens FASTA file

package/src/tests/renderers-test.ts

@@ -53,7 +53,7 @@ category('renderers', () => {
 
   test('afterConvert', async () => {
     await _testAfterConvert();
-  }, {skipReason: 'GROK-12765'});
+  });
 
   test('selectRendererBySemType', async () => {
     await _selectRendererBySemType();

package/src/tests/splitters-test.ts

@@ -2,9 +2,9 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {after, before, category, test, expect, expectArray, expectObject} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, test, expect, expectArray, expectObject, delay} from '@datagrok-libraries/utils/src/test';
 import * as C from '../utils/constants';
-import {splitToMonomers, _package, getHelmMonomers} from '../package';
+import {_package, getHelmMonomers} from '../package';
 import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
 import {TAGS as bioTAGS, splitterAsFasta, splitterAsHelm} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
@@ -89,12 +89,9 @@ category('splitters', () => {
     // call to calculate 'cell.renderer' tag
     await grok.data.detectSemanticTypes(df);
 
-    dfList.push(df);
-    tvList.push(tv);
-
-    splitToMonomers();
+    await grok.functions.call('Bio:splitToMonomers');
     expect(df.columns.names().includes('17'), true);
-  }, {skipReason: 'GROK-12766'});
+  });
 
   test('getHelmMonomers', async () => {
     const df: DG.DataFrame = DG.DataFrame.fromCsv(

package/src/utils/constants.ts

@@ -1,3 +1,5 @@
+import {pepseaMethods} from './pepsea';
+
 export enum COLUMNS_NAMES {
   SPLIT_COL = '~split',
   ACTIVITY = '~activity',
@@ -59,3 +61,17 @@ export namespace PEPSEA {
   export const SEPARATOR = '.';
 }
 
+export const kalignVersion = '3.3.1';
+
+export const msaDefaultOptions = {
+  pepsea: {
+    gapOpen: 1.53,
+    gapExtend: 0,
+    method: pepseaMethods[0],
+  },
+  kalign: {
+    gapOpen: null,
+    gapExtend: null,
+    terminalGap: null,
+  },
+} as const;

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

@@ -8,22 +8,24 @@ import {pepseaMethods, runPepsea} from './pepsea';
 import {checkInputColumnUI} from './check-input-column';
 import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
 import {_package} from '../package';
-
+import {multipleSequenceAlginmentUIOptions} from './types';
+import {kalignVersion, msaDefaultOptions} from './constants';
+import '../../css/msa.css';
 export class MsaWarning extends Error {
   constructor(message: string, options?: ErrorOptions) {
     super(message, options);
   }
 }
-type multipleSequenceAlginmentUIOptions = {col?: DG.Column<string> | null, clustersCol?: DG.Column | null,
-  pepsea?: {method?: typeof pepseaMethods[number], gapOpen?: number, gapExtend?: number}};
 
-export async function multipleSequenceAlignmentUI(options: multipleSequenceAlginmentUIOptions = {}): Promise<DG.Column> {
+export async function multipleSequenceAlignmentUI(
+  options: multipleSequenceAlginmentUIOptions = {}
+): Promise<DG.Column> {
   return new Promise(async (resolve, reject) => {
     options.clustersCol ??= null;
     options.pepsea ??= {};
-    options.pepsea.method ??= pepseaMethods[0];
-    options.pepsea.gapOpen ??= 1.53;
-    options.pepsea.gapExtend ??= 0;
+    options.pepsea.method ??= msaDefaultOptions.pepsea.method;
+    options.pepsea.gapOpen ??= msaDefaultOptions.pepsea.gapOpen;
+    options.pepsea.gapExtend ??= msaDefaultOptions.pepsea.gapExtend;
 
     const table = options.col?.dataFrame ?? grok.shell.t;
     const seqCol = options.col ?? table.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
@@ -33,20 +35,32 @@ export async function multipleSequenceAlignmentUI(options: multipleSequenceAlgin
       reject(new MsaWarning(errMsg));
     }
 
-    // UI
+    // UI for PepSea alignment
     const methodInput = ui.choiceInput('Method', options.pepsea.method, pepseaMethods);
     methodInput.setTooltip('Alignment method');
+
+    // UI for Kalign alignment
+    const terminalGapInput = ui.floatInput('Terminal gap', options?.kalign?.terminalGap ?? null);
+    terminalGapInput.setTooltip('Penalty for opening a gap at the beginning or end of the sequence');
+    const kalignVersionDiv = ui.p(`Kalign version: ${kalignVersion}`, 'kalign-version');
+
+    // shared UI
     const gapOpenInput = ui.floatInput('Gap open', options.pepsea.gapOpen);
     gapOpenInput.setTooltip('Gap opening penalty at group-to-group alignment');
     const gapExtendInput = ui.floatInput('Gap extend', options.pepsea.gapExtend);
     gapExtendInput.setTooltip('Gap extension penalty to skip the alignment');
-    const inputRootStyles = [methodInput.root.style, gapOpenInput.root.style, gapExtendInput.root.style];
+
+    const pepseaInputRootStyles: CSSStyleDeclaration[] = [methodInput.root.style];
+    const kalignInputRootStyles: CSSStyleDeclaration[] = [terminalGapInput.root.style, kalignVersionDiv.style];
+
     let performAlignment: (() => Promise<DG.Column<string>>) | undefined;
 
     // TODO: allow only macromolecule colums to be chosen
     const colInput = ui.columnInput('Sequence', table, seqCol, async () => {
       performAlignment = await onColInputChange(
-        colInput.value, table, inputRootStyles, methodInput, clustersColInput, gapOpenInput, gapExtendInput);
+        colInput.value, table, pepseaInputRootStyles, kalignInputRootStyles,
+        methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput
+      );
     }
     ) as DG.InputBase<DG.Column<string>>;
     colInput.setTooltip('Sequences column to use for alignment');
@@ -56,7 +70,9 @@ export async function multipleSequenceAlignmentUI(options: multipleSequenceAlgin
     //if column is specified (from tests), run alignment and resolve with the result
     if (options.col) {
       performAlignment = await onColInputChange(
-        options.col, table, inputRootStyles, methodInput, clustersColInput, gapOpenInput, gapExtendInput);
+        options.col, table, pepseaInputRootStyles, kalignInputRootStyles,
+        methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput
+      );
 
       await onDialogOk(colInput, table, performAlignment, resolve, reject);
       return;
@@ -67,7 +83,9 @@ export async function multipleSequenceAlignmentUI(options: multipleSequenceAlgin
       .add(methodInput)
       .add(gapOpenInput)
       .add(gapExtendInput)
-      .onOK(async () => {await onDialogOk(colInput, table, performAlignment, resolve, reject)})
+      .add(terminalGapInput)
+      .add(kalignVersionDiv)
+      .onOK(async () => { await onDialogOk(colInput, table, performAlignment, resolve, reject); })
       .show();
   });
 }
@@ -106,13 +124,11 @@ async function onDialogOk(
 
 
 async function onColInputChange(
-  col: DG.Column<string>,
-  table: DG.DataFrame,
-  inputRootStyles: CSSStyleDeclaration[],
-  methodInput: DG.InputBase<string | null>,
-  clustersColInput: DG.InputBase<DG.Column<any> | null>,
-  gapOpenInput: DG.InputBase<number | null>,
-  gapExtendInput: DG.InputBase<number | null>
+  col: DG.Column<string>, table: DG.DataFrame,
+  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>
 ): Promise<(() => Promise<DG.Column<string>>) | undefined> {
   try {
     if (col.semType !== DG.SEMTYPE.MACROMOLECULE)
@@ -122,8 +138,10 @@ async function onColInputChange(
     if (checkInputColumnUI(col, col.name,
       [NOTATION.FASTA, NOTATION.SEPARATOR], [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT], false)
     ) { // Kalign - natural alphabets. if the notation is separator, convert to fasta and then run kalign
-      for (const inputRootStyle of inputRootStyles)
-        inputRootStyle.display = 'none';
+      switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'kalign');
+      gapOpenInput.value = null;
+      gapExtendInput.value = null;
+      terminalGapInput.value = null;
       const potentialColNC = new NotationConverter(col);
       const performCol: DG.Column<string> = potentialColNC.isFasta() ? col :
         potentialColNC.convert(NOTATION.FASTA);
@@ -131,28 +149,27 @@ async function onColInputChange(
     } else if (checkInputColumnUI(col, col.name,
       [NOTATION.HELM], [], false)
     ) { // PepSeA branch - Helm notation or separator notation with unknown alphabets
-      for (const inputRootStyle of inputRootStyles)
-        inputRootStyle.removeProperty('display');
+      switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'pepsea');
+      gapOpenInput.value = msaDefaultOptions.pepsea.gapOpen;
+      gapExtendInput.value = msaDefaultOptions.pepsea.gapExtend;
 
       return async () => await runPepsea(col, unusedName, methodInput.value!,
           gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
-        } else if (checkInputColumnUI(col, col.name, [NOTATION.SEPARATOR], [ALPHABET.UN], false)) {
-          //if the column is separator with unknown alphabet, it might be helm. check if it can be converted to helm
-          const potentialColNC = new NotationConverter(col);
-          if (!await potentialColNC.checkHelmCompatibility())
-            return;
-          const helmCol = potentialColNC.convert(NOTATION.HELM);
-          for (const inputRootStyle of inputRootStyles)
-            inputRootStyle.removeProperty('display');
-          console.log(helmCol.toList());
-          // convert to helm and assign alignment function to PepSea
-    
-          return async () => await runPepsea(helmCol, unusedName, methodInput.value!,
+    } else if (checkInputColumnUI(col, col.name, [NOTATION.SEPARATOR], [ALPHABET.UN], false)) {
+      //if the column is separator with unknown alphabet, it might be helm. check if it can be converted to helm
+      const potentialColNC = new NotationConverter(col);
+      if (!await potentialColNC.checkHelmCompatibility())
+        return;
+      const helmCol = potentialColNC.convert(NOTATION.HELM);
+      switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'pepsea');
+      gapOpenInput.value = msaDefaultOptions.pepsea.gapOpen;
+      gapExtendInput.value = msaDefaultOptions.pepsea.gapExtend;
+      // convert to helm and assign alignment function to PepSea
+
+      return async () => await runPepsea(helmCol, unusedName, methodInput.value!,
             gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
     } else {
-      for (const inputRootStyle of inputRootStyles)
-        inputRootStyle.display = 'none';
-
+      switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'kalign');
       return;
     }
   } catch (err: any) {
@@ -161,3 +178,21 @@ async function onColInputChange(
     _package.logger.error(errMsg);
   }
 }
+
+type MSADialogType = 'kalign' | 'pepsea';
+
+function switchDialog(
+  pepseaInputRootStyles: CSSStyleDeclaration[], kalignInputRootStyles: CSSStyleDeclaration[], dialogType: MSADialogType
+) {
+  if (dialogType === 'kalign') {
+    for (const inputRootStyle of pepseaInputRootStyles)
+      inputRootStyle.display = 'none';
+    for (const inputRootStyle of kalignInputRootStyles)
+      inputRootStyle.removeProperty('display');
+  } else {
+    for (const inputRootStyle of kalignInputRootStyles)
+      inputRootStyle.display = 'none';
+    for (const inputRootStyle of pepseaInputRootStyles)
+      inputRootStyle.removeProperty('display');
+  }
+}

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

@@ -7,6 +7,7 @@ import {ALIGNMENT, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macr
 import Aioli from '@biowasm/aioli';
 
 import {AlignedSequenceEncoder} from '@datagrok-libraries/bio/src/sequence-encoder';
+import {kalignVersion} from './constants';
 const fastaInputFilename = 'input.fa';
 const fastaOutputFilename = 'result.fasta';
 
@@ -27,10 +28,14 @@ function _stringsToFasta(sequences: string[]): string {
  * @param {boolean} isAligned Whether the column is aligned.
  * @param {string | undefined} unUsedName
  * @param {DG.Column | null} clustersCol Column with clusters.
+ * @param {number | undefined} gapOpen Gap open penalty.
+ * @param {number | undefined} gapExtend Gap extend penalty.
+ * @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): Promise<DG.Column> {
+  clustersCol: DG.Column | null = null, gapOpen?: number, gapExtend?: number, terminalGap?: number
+): Promise<DG.Column> {
   let sequences: string[] = srcCol.toList();
 
   if (isAligned)
@@ -55,7 +60,7 @@ export async function runKalign(srcCol: DG.Column<string>, isAligned: boolean =
 
   const CLI = await new Aioli([
     'base/1.0.0',
-    {tool: 'kalign', version: '3.3.1', reinit: true}
+    {tool: 'kalign', version: kalignVersion, reinit: true}
   ]);
   const tgtCol = DG.Column.string(unUsedName, sequencesLength);
 
@@ -64,7 +69,12 @@ export async function runKalign(srcCol: DG.Column<string>, isAligned: boolean =
     const fasta = _stringsToFasta(clusterSequences);
 
     await CLI.fs.writeFile(fastaInputFilename, fasta);
-    const output = await CLI.exec(`kalign ${fastaInputFilename} -f fasta -o ${fastaOutputFilename}`);
+    const gapOpenCommand = `${gapOpen !== undefined ? ` --gpo ${gapOpen}` : ''}`;
+    const gapExtendCommand = `${gapExtend !== undefined ? ` --gpe ${gapExtend}` : ''}`;
+    const terminalGapCommand = `${terminalGap !== undefined ? ` --tgpe ${terminalGap}` : ''}`;
+    const extraParams = `${gapOpenCommand}${gapExtendCommand}${terminalGapCommand}`;
+
+    const output = await CLI.exec(`kalign ${fastaInputFilename} -f fasta -o ${fastaOutputFilename}${extraParams}`);
     console.warn(output);
 
     const buf = await CLI.cat(fastaOutputFilename);

package/src/utils/types.ts

@@ -1,5 +1,5 @@
 import * as DG from 'datagrok-api/dg';
-
+import {pepseaMethods} from './pepsea';
 export type DataFrameDict = {[key: string]: DG.DataFrame};
 
 export namespace BarChart {
@@ -11,3 +11,9 @@ export type UTypedArray = Uint8Array | Uint16Array | Uint32Array;
 //AAR: (Position: (index: indexList))
 export type SubstitutionsInfo = Map<string, Map<string, Map<number, number[] | UTypedArray>>>;
 export type SelectionObject = {[postiton: string]: string[]};
+
+export type multipleSequenceAlginmentUIOptions = {
+  col?: DG.Column<string> | null, clustersCol?: DG.Column | null,
+  pepsea?: {method?: typeof pepseaMethods[number], gapOpen?: number, gapExtend?: number},
+  kalign?: {gapOpen?: number, gapExtend?: number, terminalGap?: number}
+};