@datagrok/bio 2.15.13 → 2.16.0

package/src/utils/monomer-lib/monomer-lib.ts

@@ -39,10 +39,10 @@ export class MonomerLib extends MonomerLibBase implements IMonomerLib {
 
   constructor(
     monomers: MonomerLibDataType,
-    public readonly source: string | undefined = undefined,
+    source: string,
     public readonly error: string | undefined = undefined,
   ) {
-    super(monomers);
+    super(monomers, source);
     for (const [_monomerType, monomersOfType] of Object.entries(this._monomers)) {
       for (const [_monomerSymbol, monomer] of Object.entries(monomersOfType))
         monomer.lib = this;
@@ -112,10 +112,6 @@ export class MonomerLib extends MonomerLibBase implements IMonomerLib {
     return res;
   }
 
-  getMonomerSymbolsByType(polymerType: PolymerType): string[] {
-    return Object.keys(this._monomers[polymerType]);
-  }
-
   /** Get a list of monomers with specified element attached to specified
    * R-group
    * WARNING: RGroup numbering starts from 1, not 0*/
@@ -241,21 +237,31 @@ export class MonomerLib extends MonomerLibBase implements IMonomerLib {
     return resStr;
   }
 
-  override(data: MonomerLibData): IMonomerLibBase {
-    return new OverriddenMonomerLib(data, this);
+  override(data: MonomerLibData, source: string): IMonomerLibBase {
+    return new OverriddenMonomerLib(data, source, this);
   }
 }
 
 class OverriddenMonomerLib extends MonomerLibBase {
   constructor(
     private readonly data: MonomerLibData,
+    source: string,
     private readonly base: MonomerLibBase
   ) {
-    super(data);
+    super(data, source);
   }
 
   get onChanged(): Observable<any> { return this.base.onChanged; }
 
+  override getMonomerSymbolsByType(polymerType: PolymerType): string[] {
+    const resList = this.base.getMonomerSymbolsByType(polymerType);
+    for (const overrideSymbol of Object.keys(this.data[polymerType] ?? {})) {
+      if (!resList.includes(overrideSymbol))
+        resList.push(overrideSymbol);
+    }
+    return resList;
+  }
+
   addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
     return this.base.addMissingMonomer(polymerType, monomerSymbol);
   }

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

@@ -5,21 +5,20 @@ import * as ui from 'datagrok-api/ui';
 import {ColumnInputOptions} from '@datagrok-libraries/utils/src/type-declarations';
 import {delay} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {MsaWarning, runKalign} from './multiple-sequence-alignment';
 import {pepseaMethods, runPepsea} from './pepsea';
-import {checkInputColumnUI} from './check-input-column';
-import {multipleSequenceAlginmentUIOptions} from './types';
+import {checkInputColumn} from './check-input-column';
+import {MultipleSequenceAlignmentUIOptions} from './types';
 import {kalignVersion, msaDefaultOptions} from './constants';
 import {awaitContainerStart} from './docker';
 
-import {_package} from '../package';
-
 import '../../css/msa.css';
+import {_package} from '../package';
 
 export async function multipleSequenceAlignmentUI(
-  options: multipleSequenceAlginmentUIOptions = {},
+  options: MultipleSequenceAlignmentUIOptions, seqHelper: ISeqHelper,
 ): Promise<DG.Column> {
   return new Promise(async (resolve, reject) => {
     options.clustersCol ??= null;
@@ -70,20 +69,22 @@ export async function multipleSequenceAlignmentUI(
 
     let prevSeqCol = seqCol;
     const colInput = ui.input.column(
-      'Sequence', {table: table, value: seqCol, onValueChanged: async (value: DG.Column<any>) => {
-        if (!value || value.semType !== DG.SEMTYPE.MACROMOLECULE) {
-          okBtn.disabled = true;
-          await delay(0); // to
-          colInput.value = prevSeqCol as DG.Column<string>;
-          return;
-        }
-        prevSeqCol = value;
-        okBtn.disabled = false;
-        performAlignment = await onColInputChange(
-          colInput.value, table, pepseaInputRootStyles, kalignInputRootStyles,
-          methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput,
-        );
-      }, filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE} as ColumnInputOptions
+      'Sequence', {
+        table: table, value: seqCol, onValueChanged: async (value: DG.Column<any>) => {
+          if (!value || value.semType !== DG.SEMTYPE.MACROMOLECULE) {
+            okBtn.disabled = true;
+            await delay(0); // to
+            colInput.value = prevSeqCol as DG.Column<string>;
+            return;
+          }
+          prevSeqCol = value;
+          okBtn.disabled = false;
+          performAlignment = await onColInputChange(
+            colInput.value, table, seqHelper, pepseaInputRootStyles, kalignInputRootStyles,
+            methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput,
+          );
+        }, filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE
+      } as ColumnInputOptions
     ) as DG.InputBase<DG.Column<string>>;
     colInput.setTooltip('Sequences column to use for alignment');
     const clustersColInput = ui.input.column('Clusters', {table: table, value: options.clustersCol!});
@@ -103,7 +104,7 @@ export async function multipleSequenceAlignmentUI(
     //if column is specified (from tests), run alignment and resolve with the result
     if (options.col) {
       performAlignment = await onColInputChange(
-        options.col, table, pepseaInputRootStyles, kalignInputRootStyles,
+        options.col, table, seqHelper, pepseaInputRootStyles, kalignInputRootStyles,
         methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput,
       );
       await onDialogOk(colInput, table, performAlignment, resolve, reject);
@@ -146,7 +147,7 @@ async function onDialogOk(
 
 
 async function onColInputChange(
-  col: DG.Column<string>, table: DG.DataFrame,
+  col: DG.Column<string>, table: DG.DataFrame, seqHelper: ISeqHelper,
   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>,
@@ -157,20 +158,19 @@ async function onColInputChange(
       return;
     const unusedName = table.columns.getUnusedName(`msa(${col.name})`);
 
-    if (checkInputColumnUI(col, col.name,
-      [NOTATION.FASTA, NOTATION.SEPARATOR], [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT], false)
+    if (checkInputColumn(col, col.name, seqHelper,
+      [NOTATION.FASTA, NOTATION.SEPARATOR], [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT])[0]
     ) { // Kalign - natural alphabets. if the notation is separator, convert to fasta and then run kalign
       switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'kalign');
       gapOpenInput.value = null;
       gapExtendInput.value = null;
       terminalGapInput.value = null;
-      const potentialColSh = SeqHandler.forColumn(col);
+      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);
-    } else if (checkInputColumnUI(col, col.name,
-      [NOTATION.HELM], [], false)
-    ) { // PepSeA branch - Helm notation or separator notation with unknown alphabets
+    } else if (checkInputColumn(col, col.name, seqHelper, [NOTATION.HELM], [])[0]) {
+      // PepSeA branch - Helm notation or separator notation with unknown alphabets
       switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'pepsea');
       gapOpenInput.value ??= msaDefaultOptions.pepsea.gapOpen;
       gapExtendInput.value ??= msaDefaultOptions.pepsea.gapExtend;
@@ -180,9 +180,9 @@ async function onColInputChange(
         return runPepsea(col, unusedName, methodInput.value!,
           gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
       };
-    } else if (checkInputColumnUI(col, col.name, [NOTATION.SEPARATOR], [ALPHABET.UN], false)) {
+    } 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
-      const potentialColSh = SeqHandler.forColumn(col);
+      const potentialColSh = seqHelper.getSeqHandler(col);
       const helmCol = potentialColSh.convert(NOTATION.HELM);
       switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'pepsea');
       gapOpenInput.value ??= msaDefaultOptions.pepsea.gapOpen;

package/src/utils/save-as-fasta.ts

@@ -3,13 +3,16 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 
 import wu from 'wu';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+
 import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
+
+import {_package} from '../package';
 
 const FASTA_LINE_WIDTH = 60;
 
 /** Shows dialog to select id columns list and seq column, builds and downloads FASTA content */
-export function saveAsFastaUI() {
+export function saveAsFastaUI(): void {
   // Use grid for column order adjusted by user
   const grid: DG.Grid = grok.shell.tv.grid;
 
@@ -20,23 +23,27 @@ export function saveAsFastaUI() {
     .find((gcol: DG.GridColumn) => gcol.name.toLowerCase().indexOf('id') !== -1);
   const idDefaultValue = defaultIdGCol ? [defaultIdGCol.name] : [];
 
-  const idGColListInput = ui.input.multiChoice('Seq id columns', {value: idDefaultValue,
-    items: idGColList.map((gcol: DG.GridColumn) => gcol.name)});
+  const idGColListInput = ui.input.multiChoice('Seq id columns', {
+    value: idDefaultValue,
+    items: idGColList.map((gcol: DG.GridColumn) => gcol.name)
+  });
 
   const seqGColList: DG.GridColumn[] = wu.count(0).take(grid.columns.length)/* range rom 0 to grid.columns.length */
     .map((colI: number) => grid.columns.byIndex(colI)!)
     .filter((gc: DG.GridColumn) => {
       const col: DG.Column | null = gc.column;
       if (col && col.semType === DG.SEMTYPE.MACROMOLECULE) {
-        const sh = SeqHandler.forColumn(col);
+        const sh = _package.seqHelper.getSeqHandler(col);
         return sh.isFasta();
       }
       return false;
     }).toArray();
 
   const seqDefaultValue = seqGColList.length > 0 ? seqGColList[0].name : [];
-  const seqColInput = ui.input.choice('Seq column', {value: seqDefaultValue,
-    items: seqGColList.map((gCol: DG.GridColumn) => gCol.name)});
+  const seqColInput = ui.input.choice('Seq column', {
+    value: seqDefaultValue,
+    items: seqGColList.map((gCol: DG.GridColumn) => gCol.name)
+  });
 
   const lineWidthInput = ui.input.int('FASTA line width', {value: FASTA_LINE_WIDTH});
 
@@ -56,7 +63,8 @@ export function saveAsFastaUI() {
       if (!valueSeqCol)
         grok.shell.warning(`Seq column is mandatory to save as FASTA.`);
 
-      const resFastaTxt: string = saveAsFastaDo(valueIdColList, valueSeqCol!, valueLineWidth);
+      const seqHandler = _package.seqHelper.getSeqHandler(valueSeqCol!);
+      const resFastaTxt: string = saveAsFastaDo(valueIdColList, seqHandler, valueLineWidth);
 
       const aEl: HTMLAnchorElement = document.createElement('a');
       aEl.setAttribute('href', `data:text/plain;charset=utf-8,${encodeURIComponent(resFastaTxt)}`);
@@ -75,17 +83,16 @@ export function saveAsFastaUI() {
  * @return {string} FASTA content
  */
 export function saveAsFastaDo(
-  idColList: DG.Column[], seqCol: DG.Column, lineWidth: number = FASTA_LINE_WIDTH, lineSeparator: string = '\n',
+  idColList: DG.Column[], seqHandler: ISeqHandler, lineWidth: number = FASTA_LINE_WIDTH, lineSeparator: string = '\n',
 ): string {
-  const sh = SeqHandler.forColumn(seqCol);
   const fastaLines: string[] = [];
 
-  for (let rowIdx: number = 0; rowIdx < seqCol.length; rowIdx++) {
+  for (let rowIdx: number = 0; rowIdx < seqHandler.length; rowIdx++) {
     // multiple identifiers separated by vertical bars
     // https://en.wikipedia.org/wiki/FASTA_format
 
     const seqId: string = idColList.map((col) => col.get(rowIdx).toString()).join('|');
-    const srcSS = sh.getSplitted(rowIdx);
+    const srcSS = seqHandler.getSplitted(rowIdx);
     const seqLineList: string[] = wrapSequence(srcSS, lineWidth);
 
     fastaLines.push(`>${seqId}${lineSeparator}`);