@datagrok/bio 2.1.12 → 2.4.2

package/src/utils/monomer-lib.ts

@@ -0,0 +1,174 @@
+// import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+import {Observable, Subject} from 'rxjs';
+import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types/index';
+import {
+  createJsonMonomerLibFromSdf,
+  expectedMonomerData,
+  IMonomerLibHelper
+} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+// -- Monomer libraries --
+export const LIB_STORAGE_NAME = 'Libraries';
+export const LIB_PATH = 'System:AppData/Bio/libraries/';
+export const LIB_DEFAULT: { [fileName: string]: string } = {'HELMCoreLibrary.json': 'HELMCoreLibrary.json'};
+
+export class MonomerLib implements IMonomerLib {
+  private _monomers: { [type: string]: { [name: string]: Monomer } } = {};
+  private _onChanged = new Subject<any>();
+
+  constructor(monomers: { [type: string]: { [name: string]: Monomer } }) {
+    this._monomers = monomers;
+  }
+
+  getMonomer(monomerType: string, monomerName: string): Monomer | null {
+    if (monomerType in this._monomers! && monomerName in this._monomers![monomerType])
+      return this._monomers![monomerType][monomerName];
+    else
+      return null;
+  }
+
+  getTypes(): string[] {
+    return Object.keys(this._monomers);
+  }
+
+  getMonomerMolsByType(type: string): { [symbol: string]: string } {
+    const res: { [symbol: string]: string } = {};
+
+    Object.keys(this._monomers[type]).forEach((monomerSymbol) => {
+      res[monomerSymbol] = this._monomers[type][monomerSymbol].molfile;
+    });
+
+    return res;
+  }
+
+  getMonomerNamesByType(type: string): string[] {
+    return Object.keys(this._monomers[type]);
+  }
+
+  get onChanged(): Observable<any> {
+    return this._onChanged;
+  }
+
+  private _updateInt(lib: IMonomerLib): void {
+    const typesNew = lib.getTypes();
+    const types = this.getTypes();
+
+    typesNew.forEach((type) => {
+      //could possibly rewrite -> TODO: check duplicated monomer symbol
+
+      if (!types.includes(type))
+        this._monomers![type] = {};
+
+      const monomers = lib.getMonomerNamesByType(type);
+      monomers.forEach((monomerName) => {
+        this._monomers[type][monomerName] = lib.getMonomer(type, monomerName)!;
+      });
+    });
+  }
+
+  public update(lib: IMonomerLib): void {
+    this._updateInt(lib);
+    this._onChanged.next();
+  }
+
+  public updateLibs(libList: IMonomerLib[], reload: boolean = false): void {
+    if (reload) this._monomers = {};
+    for (const lib of libList) this._updateInt(lib);
+    this._onChanged.next();
+  }
+
+  public clear(): void {
+    this._monomers = {};
+    this._onChanged.next();
+  }
+}
+
+export class MonomerLibHelper implements IMonomerLibHelper {
+  private readonly _monomerLib: MonomerLib = new MonomerLib({});
+
+  /** Protect constructor to prevent multiple instantiation. */
+  protected constructor() {}
+
+  /** Singleton monomer library */
+  getBioLib(): IMonomerLib {
+    return this._monomerLib;
+  }
+
+  private loadLibrariesPromise: Promise<void> = Promise.resolve();
+
+  /** Loads libraries based on settings in user storage {@link LIB_STORAGE_NAME}
+   * @param {boolean} reload Clean {@link monomerLib} before load libraries [false]
+   */
+  async loadLibraries(reload: boolean = false): Promise<void> {
+    return this.loadLibrariesPromise = this.loadLibrariesPromise.then(async () => {
+      const userLibrariesSettings: string[] = Object.keys(await grok.dapi.userDataStorage.get(LIB_STORAGE_NAME, true));
+      const libs: IMonomerLib[] = await Promise.all(userLibrariesSettings.map((libFileName) => {
+        //TODO handle whether files are in place
+        return this.readLibrary(LIB_PATH, libFileName);
+      }));
+      this._monomerLib.updateLibs(libs, reload);
+    });
+  }
+
+  /** Reads library from file shares, handles .json and .sdf */
+  async readLibrary(path: string, fileName: string): Promise<IMonomerLib> {
+    let data: any[] = [];
+    let file;
+    let dfSdf;
+    const fileSource = new DG.FileSource(path);
+    if (fileName.endsWith('.sdf')) {
+      const funcList: DG.Func[] = DG.Func.find({package: 'Chem', name: 'importSdf'});
+      if (funcList.length === 1) {
+        file = await fileSource.readAsBytes(fileName);
+        dfSdf = await grok.functions.call('Chem:importSdf', {bytes: file});
+        data = createJsonMonomerLibFromSdf(dfSdf[0]);
+      } else {
+        grok.shell.warning('Chem package is not installed');
+      }
+    } else {
+      const file = await fileSource.readAsText(fileName);
+      data = JSON.parse(file);
+    }
+
+    const monomers: { [type: string]: { [name: string]: Monomer } } = {};
+    const types: string[] = [];
+    //group monomers by their type
+    data.forEach((monomer) => {
+      const monomerAdd: Monomer = {
+        'symbol': monomer['symbol'],
+        'name': monomer['name'],
+        'naturalAnalog': monomer['naturalAnalog'],
+        'molfile': monomer['molfile'],
+        'rgroups': monomer['rgroups'],
+        'polymerType': monomer['polymerType'],
+        'monomerType': monomer['monomerType'],
+        'data': {}
+      };
+
+      Object.keys(monomer).forEach((prop) => {
+        if (!expectedMonomerData.includes(prop))
+          monomerAdd.data[prop] = monomer[prop];
+      });
+
+      if (!types.includes(monomer['polymerType'])) {
+        monomers[monomer['polymerType']] = {};
+        types.push(monomer['polymerType']);
+      }
+
+      monomers[monomer['polymerType']][monomer['symbol']] = monomerAdd;
+    });
+
+    return new MonomerLib(monomers);
+  }
+
+  // -- Instance singleton --
+  private static _instance: MonomerLibHelper | null = null;
+
+  public static get instance(): MonomerLibHelper {
+    if (!MonomerLibHelper._instance) MonomerLibHelper._instance = new MonomerLibHelper();
+    return MonomerLibHelper._instance;
+  }
+}

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

@@ -1,15 +1,14 @@
 /* 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 {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
-import {TAGS as bioTAGS} from '@datagrok-libraries/bio';
-//@ts-ignore
+import {TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+//@ts-ignore: there are no types for this library
 import Aioli from '@biowasm/aioli';
 
 import {AlignedSequenceEncoder} from '@datagrok-libraries/bio/src/sequence-encoder';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+const fastaInputFilename = 'input.fa';
+const fastaOutputFilename = 'result.fasta';
 
 /**
  * Converts array of sequences into simple fasta string.
@@ -29,31 +28,56 @@ function _stringsToFasta(sequences: string[]): string {
  * @param {string} unUsedName
  * @return {Promise<DG.Column>} Aligned sequences.
  */
-export async function runKalign(srcCol: DG.Column, isAligned = false, unUsedName: string = ''): Promise<DG.Column> {
-  let sequences = srcCol.toList();
+export async function runKalign(srcCol: DG.Column<string>, isAligned: boolean = false, unUsedName: string = '',
+  clustersCol: DG.Column | null = null): Promise<DG.Column> {
+  let sequences: string[] = srcCol.toList();
 
   if (isAligned)
-    sequences = sequences.map((v: string, _) => AlignedSequenceEncoder.clean(v).replace(/\-/g, ''));
+    sequences = sequences.map((v: string) => AlignedSequenceEncoder.clean(v).replace(/\-/g, ''));
+
+  const sequencesLength = srcCol.length;
+  clustersCol ??= DG.Column.string('Clusters', sequencesLength).init('0');
+  if (clustersCol.type != DG.COLUMN_TYPE.STRING)
+    clustersCol = clustersCol.convertTo(DG.TYPE.STRING);
+  clustersCol.compact();
+  
+  //TODO: use fixed-size inner arrays, but first need to expose the method to get each category count
+  const clustersColCategories = clustersCol.categories;
+  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);
+  }
 
-  const fasta = _stringsToFasta(sequences);
   const CLI = await new Aioli([
     'base/1.0.0',
     {tool: 'kalign', version: '3.3.1', reinit: true}
   ]);
+  const tgtCol = DG.Column.string(unUsedName, sequencesLength);
 
-  console.log(['fasta.length =', fasta.length]);
+  for (let clusterIdx = 0; clusterIdx < clustersColCategories.length; ++clusterIdx) {
+    const clusterSequences = fastaSequences[clusterIdx];
+    const fasta = _stringsToFasta(clusterSequences);
+    
+    console.log(['fasta.length =', fasta.length]);
 
-  await CLI.fs.writeFile('input.fa', fasta);
-  const output = await CLI.exec('kalign input.fa -f fasta -o result.fasta');
-  console.warn(output);
+    await CLI.fs.writeFile(fastaInputFilename, fasta);
+    const output = await CLI.exec(`kalign ${fastaInputFilename} -f fasta -o ${fastaOutputFilename}`);
+    console.warn(output);
 
-  const buf = await CLI.cat('result.fasta');
-  if (!buf)
-    throw new Error(`kalign output no result`);
+    const buf = await CLI.cat(fastaOutputFilename);
+    if (!buf)
+      throw new Error(`kalign output no result`);
 
-  const ffh = new FastaFileHandler(buf);
-  const aligned = ffh.sequencesArray; // array of sequences extracted from FASTA
-  const tgtCol = DG.Column.fromStrings(unUsedName, aligned);
+    const ffh = new FastaFileHandler(buf);
+    const aligned = ffh.sequencesArray; // array of sequences extracted from FASTA
+    const clusterRowIds = clusterIndexes[clusterIdx];
+    for (let clusterRowIdIdx = 0; clusterRowIdIdx < aligned.length; ++clusterRowIdIdx)
+      tgtCol.set(clusterRowIds[clusterRowIdIdx], aligned[clusterRowIdIdx]);
+  }
 
   // units
   const srcUnits = srcCol.getTag(DG.TAGS.UNITS);
@@ -70,7 +94,7 @@ export async function runKalign(srcCol: DG.Column, isAligned = false, unUsedName
   return tgtCol;
 }
 
-export async function testMSAEnoughMemory(col: DG.Column): Promise<void> {
+export async function testMSAEnoughMemory(col: DG.Column<string>): Promise<void> {
   const sequencesCount = col.length;
   const delta = sequencesCount / 100;
 

package/src/utils/pepsea.ts

@@ -0,0 +1,78 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import {NOTATION, TAGS as bioTAGS, ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import * as C from './constants';
+
+export const pepseaMethods = ['mafft --auto', 'mafft', 'linsi', 'ginsi', 'einsi', 'fftns', 'fftnsi', 'nwns', 'nwnsi'];
+const alignmentObjectMetaKeys = ['AlignedSeq', 'AlignedSubpeptide', 'HELM', 'ID', 'PolymerID'];
+type PepseaRepsonse = {
+  Alignment: {
+    PolymerID: string, AlignedSubpeptide: string, HELM: string, ID: string, AlignedSeq: string, [key: string]: string,
+  }[],
+  AlignmentScore: {[key: string]: number | null},
+};
+type PepseaBodyUnit = {ID: string, HELM: string};
+
+export async function runPepsea(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,
+  ): Promise<DG.Column<string>> {
+  const peptideCount = srcCol.length;
+  clustersCol ??= DG.Column.int('Clusters', peptideCount).init(0);
+  if (clustersCol.type != DG.COLUMN_TYPE.STRING)
+    clustersCol = clustersCol.convertTo(DG.TYPE.STRING);
+
+  const clusters = clustersCol.categories;
+  const bodies: PepseaBodyUnit[][] = new Array(clusters.length);
+
+  // Grouping data by clusters
+  for (let rowIndex = 0; rowIndex < peptideCount; ++rowIndex) {
+    const cluster = clustersCol.get(rowIndex) as string;
+    if (cluster === '')
+      continue;
+
+    const clusterId = clusters.indexOf(cluster);
+    const helmSeq = srcCol.get(rowIndex);
+    if (helmSeq)
+      (bodies[clusterId] ??= []).push({ID: rowIndex.toString(), HELM: helmSeq});
+  }
+
+  //@ts-ignore: this is a temporary workaround for the issue with docker containers. This will be fixed in 1.14.0
+  const pepseaContainer = await (grok.dapi.docker !== undefined ? grok.dapi.docker.dockerContainers : grok.dapi.dockerfiles).filter('bio').first();
+  const alignedSequences: string[] = new Array(peptideCount);
+  for (const body of bodies) { // getting aligned sequences for each cluster
+    const alignedObject = await requestAlignedObjects(pepseaContainer.id, body, method, gapOpen, gapExtend);
+    const alignments = alignedObject.Alignment;
+
+    for (const alignment of alignments) {  // filling alignedSequencesCol
+      alignedSequences[parseInt(alignment.ID)] = Object.entries(alignment)
+        .filter((v) => !alignmentObjectMetaKeys.includes(v[0]))
+        .map((v) => v[1] !== '-' ? v[1] : '')
+        .join(C.PEPSEA.SEPARATOR);
+    }
+  }
+
+  const alignedSequencesCol: DG.Column<string> = DG.Column.fromStrings(unUsedName, alignedSequences);
+  alignedSequencesCol.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
+  alignedSequencesCol.setTag(bioTAGS.separator, C.PEPSEA.SEPARATOR);
+  alignedSequencesCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
+  alignedSequencesCol.setTag(bioTAGS.alphabet, ALPHABET.UN);
+  alignedSequencesCol.semType = DG.SEMTYPE.MACROMOLECULE;
+
+  return alignedSequencesCol;
+}
+
+async function requestAlignedObjects(dockerfileId: string, body: PepseaBodyUnit[], method: string, gapOpen: number,
+  gapExtend: number): Promise<PepseaRepsonse> {
+  const params = {
+    method: 'POST',
+    headers: {'Accept': 'application/json', 'Content-Type': 'application/json'},
+    body: JSON.stringify(body),
+  };
+  const path = `/align?method=${method}&gap_open=${gapOpen}&gap_extend=${gapExtend}`;
+  //@ts-ignore: this is a temporary workaround for the issue with docker containers
+  const response = await (grok.dapi.docker !== undefined ? grok.dapi.docker.dockerContainers : grok.dapi.dockerfiles)
+    .request(dockerfileId, path, params);
+  return JSON.parse(response ?? '{}');
+}

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

@@ -3,7 +3,8 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 
 import wu from 'wu';
-import {splitterAsFasta, SplitterFunc, UnitsHandler} from '@datagrok-libraries/bio';
+import {splitterAsFasta, SplitterFunc} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 const FASTA_LINE_WIDTH = 60;
 

package/src/utils/ui-utils.ts

@@ -1,4 +1,16 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+export function getMacromoleculeColumn(): DG.Column | any {
+  const col = grok.shell.t.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
+  if (col === null) {
+    grok.shell.error('Current table does not contain macromolecules');
+    return;
+  }
+  return col;
+}
+
 export function updateDivInnerHTML(div: HTMLElement, content: string | Node): void {
-    div.innerHTML = '';
-    div.append(content);
-  }
+  div.innerHTML = '';
+  div.append(content);
+}