@datagrok/peptides 0.8.5 → 0.8.9

package/src/model.ts

@@ -1,103 +1,125 @@
 import * as DG from 'datagrok-api/dg';
 
 import {describe} from './describe';
-import {Subject} from 'rxjs';
-
-/**
- * Model class for SAR viewers that retrieves and stores data.
- *
- * @class SARViewerModel
- */
-class SARViewerModel {
-  private viewerGrid: Subject<DG.Grid> = new Subject<DG.Grid>();
-  private viewerVGrid: Subject<DG.Grid> = new Subject<DG.Grid>();
-  private statsDf: Subject<DG.DataFrame> = new Subject<DG.DataFrame>();
-  private groupMapping: Subject<{[key: string]: string}> = new Subject<{[key: string]: string}>();
-  public viewerGrid$;
-  public viewerVGrid$;
-  public statsDf$;
-  public groupMapping$;
+import {Subject, Observable} from 'rxjs';
+import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
+import {addViewerToHeader, StackedBarChart} from './viewers/stacked-barchart-viewer';
+
+export class PeptidesModel {
+  // private _viewerGrid: DG.Grid;
+  // private viewerVGrid: DG.Grid;
+  // private _statsDf: DG.DataFrame;
+  // private groupMapping: StringDictionary;
   private dataFrame: DG.DataFrame | null;
   private activityColumn: string | null;
   private activityScaling: string | null;
   private sourceGrid: DG.Grid | null;
   private twoColorMode: boolean | null;
   private initialBitset: DG.BitSet | null;
-  private isUpdating = false;
-  grouping: boolean;
-
-  /**
-   * Creates an instance of SARViewerModel.
-   *
-   * @memberof SARViewerModel
-   */
-  constructor() {
-    this.dataFrame = null;
+  private isUpdating: boolean = false;
+  private grouping: boolean = false;
+  private substFlag = false;
+  private statsDataFrameSubject = new Subject<DG.DataFrame>();
+  private sarGridSubject = new Subject<DG.Grid>();
+  private sarVGridSubject = new Subject<DG.Grid>();
+  private groupMappingSubject = new Subject<StringDictionary>();
+  private substFlagSubject = new Subject<boolean>();
+  private static _modelName = 'peptidesModel';
+
+  private constructor(dataFrame: DG.DataFrame) {
+    this.dataFrame = dataFrame;
     this.activityColumn = null;
     this.activityScaling = null;
     this.sourceGrid = null;
     this.twoColorMode = null;
     this.initialBitset = null;
-    this.grouping = false;
-    this.viewerGrid$ = this.viewerGrid.asObservable();
-    this.viewerVGrid$ = this.viewerVGrid.asObservable();
-    this.statsDf$ = this.statsDf.asObservable();
-    this.groupMapping$ = this.groupMapping.asObservable();
+
+    // this._statsDf = DG.DataFrame.create();
+    // this._viewerGrid = DG.Grid.create(this.statsDf);
+    // this.viewerVGrid = DG.Grid.create(this.statsDf);
+    // this.groupMapping = {};
+
+    // this.statsDataFrameObservable = new Observable(subject => subject.next(this.statsDf));
+    // this.sarGridObservable = new Observable(subject => subject.next(this.viewerGrid));
+    // this.sarVGridObservable = new Observable(subject => subject.next(this.viewerVGrid));
+    // this.groupMappingObservable = new Observable(subject => subject.next(this.groupMapping));
+  }
+
+  // get statsDf() {
+  //   return this._statsDf;
+  // }
+
+  // get viewerGrid() {
+  //   return this._viewerGrid;
+  // }
+
+  get onStatsDataFrameChanged(): Observable<DG.DataFrame> {
+    return this.statsDataFrameSubject.asObservable();
+  }
+
+  get onSARGridChanged(): Observable<DG.Grid> {
+    return this.sarGridSubject.asObservable();
+  }
+
+  get onSARVGridChanged(): Observable<DG.Grid> {
+    return this.sarVGridSubject.asObservable();
+  }
+
+  get onGroupMappingChanged(): Observable<StringDictionary> {
+    return this.groupMappingSubject.asObservable();
+  }
+
+  get onSubstFlagChanged(): Observable<boolean> {
+    return this.substFlagSubject.asObservable();
   }
 
-  /**
-   * Updates data with using specified parameters.
-   *
-   * @param {DG.DataFrame} df Working table.
-   * @param {string} activityCol Activity column name.
-   * @param {string} activityScaling Activity scaling method.
-   * @param {DG.Grid} sourceGrid Working table grid.
-   * @param {boolean} twoColorMode Bidirectional analysis enabled.
-   * @param {(DG.BitSet | null)} initialBitset Initial bitset.
-   * @param {boolean} grouping Grouping enabled.
-   * @memberof SARViewerModel
-   */
   async updateData(
-    df: DG.DataFrame,
-    activityCol: string,
-    activityScaling: string,
-    sourceGrid: DG.Grid,
-    twoColorMode: boolean,
-    initialBitset: DG.BitSet | null,
-    grouping: boolean,
-  ) {
-    this.dataFrame = df;
-    this.activityColumn = activityCol;
-    this.activityScaling = activityScaling;
-    this.sourceGrid = sourceGrid;
-    this.twoColorMode = twoColorMode;
-    this.initialBitset = initialBitset;
-    this.grouping = grouping;
+    df: DG.DataFrame | null, activityCol: string | null, activityScaling: string | null, sourceGrid: DG.Grid | null,
+    twoColorMode: boolean | null, initialBitset: DG.BitSet | null, grouping: boolean | null) {
+    this.dataFrame = df ?? this.dataFrame;
+    this.activityColumn = activityCol ?? this.activityColumn;
+    this.activityScaling = activityScaling ?? this.activityScaling;
+    this.sourceGrid = sourceGrid ?? this.sourceGrid;
+    this.twoColorMode = twoColorMode ?? this.twoColorMode;
+    this.initialBitset = initialBitset ?? this.initialBitset;
+    this.grouping = grouping ?? this.grouping;
     await this.updateDefault();
   }
 
-  /**
-   * Update data using current parameters.
-   *
-   * @memberof SARViewerModel
-   */
   async updateDefault() {
-    if (
-      this.dataFrame && this.activityColumn && this.activityScaling &&
-        this.sourceGrid && this.twoColorMode !== null && !this.isUpdating
-    ) {
+    if (this.dataFrame && this.activityColumn && this.activityScaling && this.sourceGrid &&
+        this.twoColorMode !== null && !this.isUpdating) {
       this.isUpdating = true;
       const [viewerGrid, viewerVGrid, statsDf, groupMapping] = await describe(
-        this.dataFrame, this.activityColumn, this.activityScaling,
-        this.sourceGrid, this.twoColorMode, this.initialBitset, this.grouping,
-      );
-      this.viewerGrid.next(viewerGrid);
-      this.viewerVGrid.next(viewerVGrid);
-      this.statsDf.next(statsDf);
-      this.groupMapping.next(groupMapping);
+        this.dataFrame, this.activityColumn, this.activityScaling, this.sourceGrid, this.twoColorMode,
+        this.initialBitset, this.grouping);
+      this.statsDataFrameSubject.next(statsDf);
+      this.groupMappingSubject.next(groupMapping);
+      this.sarGridSubject.next(viewerGrid);
+      this.sarVGridSubject.next(viewerVGrid);
+      this.substFlag = !this.substFlag;
+      this.substFlagSubject.next(this.substFlag);
+
+      this.sourceGrid.invalidate();
+
       this.isUpdating = false;
     }
+
+    await this.updateBarchart();
   }
-}
 
-export const model = new SARViewerModel();
+  async updateBarchart() {
+    const stackedBarchart = await this.dataFrame?.plot.fromType('StackedBarChartAA') as StackedBarChart;
+    if (stackedBarchart && this.sourceGrid)
+      addViewerToHeader(this.sourceGrid, stackedBarchart);
+  }
+
+  static get modelName() {
+    return PeptidesModel._modelName;
+  }
+
+  static getOrInit(dataFrame: DG.DataFrame): PeptidesModel {
+    dataFrame.temp[PeptidesModel.modelName] ??= new PeptidesModel(dataFrame);
+    return dataFrame.temp[PeptidesModel.modelName];
+  }
+}

package/src/monomer-library.ts

@@ -0,0 +1,184 @@
+/** HELM associated sdf libraries with monomer processing*/
+export class MonomerLibrary {
+  private monomerFields: string[] = [
+    'molecule', 'MonomerType', 'MonomerNaturalAnalogCode', 'MonomerName', 'MonomerCode', 'MonomerCaps', 'BranchMonomer',
+  ];
+  private library: {
+    [name: string]: {
+      mol: string,
+      type: string,
+      analogueCode: string,
+      linkages: { [link: string]: { atomNumber: number, type: string } }
+    }
+  } = {};
+  private monomers: string[] = [];
+
+  constructor(sdf: string) {
+    const sdfReader = new SDFReader();
+    const data = sdfReader.getColls(sdf);
+    this.monomerFields.forEach((f) => {
+      if (!(f in data))
+        throw new Error(`Monomer library was not compiled: ${f} field is absent in provided file`);
+
+      if (data[f].length != data.molecule.length)
+        throw new Error(`Monomer library was not compiled: ${f} field is not presented for each monomer`);
+    });
+
+    for (let i = 0; i < data.molecule.length; i++) {
+      const linkData = this.getLinkData(data.molecule[i], data.MonomerCaps[i], data.MonomerName[i]);
+      const entry = {
+        mol: data.molecule[i],
+        type: 'Peptide',
+        code: data.MonomerCode[i],
+        analogueCode: data.MonomerNaturalAnalogCode[i],
+        linkages: linkData,
+      };
+
+      const name = data.MonomerCode[i] !== '.' ? data.MonomerCode[i] : data.MonomerName[i];
+      this.library[name] = entry;
+      this.monomers.push(name);
+    }
+  }
+
+  /** getting full monomer information from monomer library*/
+  public getMonomerEntry(name: string) {
+    if (!this.monomers.includes(name))
+      throw new Error(`Monomer library do not contain ${name} monomer`);
+
+
+    return this.library[name];
+  }
+
+  /** getting mol as string for monomer*/
+  public getMonomerMol(name: string) {
+    if (!this.monomers.includes(name))
+      throw new Error(`Monomer library do not contain ${name} monomer`);
+
+
+    const entry = this.library[name];
+    let monomerMol = entry.mol.replace(/M  RGP  .+\n/, '');
+
+    //order matters
+    const links = Object.keys(entry.linkages);
+    for (let i = 0; i < links.length; i++)
+      monomerMol = monomerMol.replace('R#', entry.linkages[links[i]].type + ' ');
+
+
+    return monomerMol;
+  }
+
+  /** getting the list of the minomers available in library*/
+  get monomerNames() {
+    return this.monomers;
+  }
+
+  private getLinkData(mol: string, caps: string, name: string) {
+    const rawData = mol.match(/M  RGP  .+/);
+    if (rawData === null)
+      throw new Error(`Monomer library was not compiled: ${name} entry has no RGP`);
+
+
+    const types: { [code: string]: string } = {};
+    caps.split('\n')?.forEach((e) => {
+      types[e.match(/\d+/)![0]] = e.match(/(?<=\])\w+/)![0];
+    });
+
+    const data = rawData![0].replace('M  RGP  ', '').split(/\s+/);
+    const res: { [link: string]: { atomNumber: number, type: string } } = {};
+    for (let i = 0; i < parseInt(data[0]); i++) {
+      const code = parseInt(data[2 * i + 2]);
+      let type = '';
+      switch (code) {
+      case 1:
+        type = 'N-terminal';
+        break;
+      case 2:
+        type = 'C-terminal';
+        break;
+      case 3:
+        type = 'branch';
+        break;
+      default:
+        break;
+      }
+      res[type] = {atomNumber: parseInt(data[2 * i + 1]), type: types[code]};
+    }
+
+    return res;
+  }
+}
+
+//TODO: merge with Chem version
+class SDFReader {
+  dataColls: { [_: string]: any };
+
+  constructor() {
+    this.dataColls = {'molecule': []};
+  }
+
+  getColls(content: string) {
+    this.read(content);
+    return this.dataColls;
+  }
+
+  read(content: string) {
+    content = content.replaceAll('\r', ''); //equalize old and new sdf standards
+    let startIndex = content.indexOf('$$$$', 0);
+    this.parse(content, 0, startIndex, (name: string, val: any) => { // TODO: type
+      this.dataColls[name] = [];
+      this.dataColls[name].push(val);
+    });
+    startIndex += 5;
+    while (startIndex > -1 && startIndex < content.length)
+      startIndex = this.readNext(content, startIndex);
+  }
+
+  readNext(content: string, startIndex: number) {
+    const nextStartIndex = content.indexOf('$$$$', startIndex);
+    if (nextStartIndex === -1)
+      return -1;
+    else {
+      this.parse(content, startIndex, nextStartIndex,
+        (name: string, val: number) => this.dataColls[name].push(val));
+    }
+
+    if (nextStartIndex > -1)
+      return nextStartIndex + 5;
+
+
+    return nextStartIndex;
+  }
+
+  parse(content: string, start: number, end: number, handler: any) {
+    const molEnd = +content.indexOf('M  END\n', start) + 7;
+    let localEnd = start;
+    this.dataColls['molecule'].push(content.substr(start, molEnd - start));
+
+    start = molEnd;
+    while (localEnd < end) {
+      start = content.indexOf('> <', localEnd);
+      if (start === -1)
+        return;
+
+
+      start += 3;
+      localEnd = content.indexOf('>\n', start);
+      if (localEnd === -1)
+        return;
+
+
+      const propertyName = content.substring(start, localEnd);
+      start = localEnd + 2;
+
+      localEnd = content.indexOf('\n', start);
+      if (localEnd === -1)
+        localEnd = end;
+      else if (content[localEnd + 1] != '\n')
+        localEnd = content.indexOf('\n', ++localEnd);
+      ;
+
+      handler(propertyName, content.substring(start, localEnd));
+      localEnd += 2;
+    }
+  }
+}

package/src/package-test.ts

@@ -4,15 +4,16 @@ import {runTests} from '@datagrok-libraries/utils/src/test';
 
 import './tests/peptide-space-test';
 import './tests/peptides-tests';
+import './tests/msa-tests';
 
 export const _package = new DG.Package();
 
 //name: test
 //input: string category {optional: true}
-//input: string test {optional: true}
+//input: string t {optional: true}
 //output: dataframe result
 //top-menu: Tools | Dev | JS API Tests
-export async function test(category: string, test: string): Promise<DG.DataFrame> {
-  const data = await runTests({category, test});
+export async function test(category: string, t: string): Promise<DG.DataFrame> {
+  const data = await runTests({category, test: t});
   return DG.DataFrame.fromObjects(data)!;
 }

package/src/package.ts

@@ -5,6 +5,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {
   AlignedSequenceCellRenderer,
+  AlignedSequenceDifferenceCellRenderer,
   AminoAcidsCellRenderer,
 } from './utils/cell-renderer';
 import {Logo} from './viewers/logo-viewer';
@@ -16,13 +17,14 @@ import {manualAlignmentWidget} from './widgets/manual-alignment';
 import {SARViewer, SARViewerVertical} from './viewers/sar-viewer';
 import {peptideMoleculeWidget, getMolecule} from './widgets/peptide-molecule';
 import {SubstViewer} from './viewers/subst-viewer';
-import {runKalign} from './utils/multiple-sequence-alignment';
+import {substTableWidget} from './widgets/subst-table';
+import {msaWidget} from './widgets/multiple-sequence-alignment';
 
 export const _package = new DG.Package();
-let tableGrid: DG.Grid;
-let currentDf: DG.DataFrame;
-let alignedSequenceCol: DG.Column;
-let view: DG.TableView;
+let currentGrid: DG.Grid;
+let currentTable: DG.DataFrame;
+let alignedSequenceColumn: DG.Column;
+let currentView: DG.TableView;
 
 async function main(chosenFile: string) {
   const pi = DG.TaskBarProgressIndicator.create('Loading Peptides');
@@ -31,16 +33,16 @@ async function main(chosenFile: string) {
   peptides.name = 'Peptides';
   peptides.setTag('dataType', 'peptides');
   const view = grok.shell.addTableView(peptides);
-  tableGrid = view.grid;
+  currentGrid = view.grid;
   view.name = 'PeptidesView';
   grok.shell.windows.showProperties = true;
 
   pi.close();
 }
 
-//name: Peptides App
+//name: Peptides
 //tags: app
-export function Peptides() {
+export async function Peptides() {
   const wikiLink = ui.link('wiki', 'https://github.com/datagrok-ai/public/blob/master/help/domains/bio/peptides.md');
   const textLink = ui.inlineText(['For more details, see our ', wikiLink, '.']);
 
@@ -73,8 +75,8 @@ export function Peptides() {
     appDescription,
     ui.info([textLink]),
     ui.divH([
-      ui.button('Open peptide sequences demonstration set', () => main('aligned.csv'), ''),
-      ui.button('Open complex case demo', () => main('aligned_2.csv'), ''),
+      ui.button('Simple demo', () => main('aligned.csv'), ''),
+      ui.button('Complex demo', () => main('aligned_2.csv'), ''),
     ]),
   ]);
 }
@@ -84,14 +86,12 @@ export function Peptides() {
 //input: column col {semType: alignedSequence}
 //output: widget result
 export async function peptidesPanel(col: DG.Column): Promise<DG.Widget> {
-  if (col.getTag('isAnalysisApplicable') === 'false') {
+  if (!(col.temp['isAnalysisApplicable'] ?? true))
     return new DG.Widget(ui.divText('Analysis is not applicable'));
-  }
-  view = (grok.shell.v as DG.TableView);
-  tableGrid = view.grid;
-  currentDf = col.dataFrame;
-  alignedSequenceCol = col;
-  return await analyzePeptidesWidget(col, view, tableGrid, currentDf);
+
+  [currentView, currentGrid, currentTable, alignedSequenceColumn] =
+    getOrDefineWIP(currentView, currentGrid, currentTable, col);
+  return await analyzePeptidesWidget(col, currentView, currentGrid, currentTable);
 }
 
 //name: peptide-sar-viewer
@@ -136,6 +136,17 @@ export async function peptideMolecule(peptide: string): Promise<DG.Widget> {
   return await peptideMoleculeWidget(peptide);
 }
 
+//name: Peptide Molecule
+//tags: panel, widgets
+//input: string aar {semType: aminoAcids}
+//output: widget result
+export async function peptideMolecule2(aar: string): Promise<DG.Widget> {
+  [currentView, currentGrid, currentTable, alignedSequenceColumn] =
+    getOrDefineWIP(currentView, currentGrid, currentTable, alignedSequenceColumn);
+  const peptide = alignedSequenceColumn.get(currentTable.currentRowIdx);
+  return await peptideMolecule(peptide);
+}
+
 //name: StackedBarChartAA
 //tags: viewer
 //output: viewer result
@@ -171,7 +182,10 @@ export function logov() {
 //input: string monomer {semType: aminoAcids}
 //output: widget result
 export function manualAlignment(monomer: string) {
-  return manualAlignmentWidget(alignedSequenceCol, currentDf);
+  [currentView, currentGrid, currentTable, alignedSequenceColumn] =
+    getOrDefineWIP(currentView, currentGrid, currentTable, alignedSequenceColumn);
+  //TODO: recalculate Molfile and Molecule panels on sequence update
+  return manualAlignmentWidget(alignedSequenceColumn, currentTable);
 }
 
 //name: Peptide Space
@@ -179,7 +193,9 @@ export function manualAlignment(monomer: string) {
 //input: column col {semType: alignedSequence}
 //output: widget result
 export async function peptideSpacePanel(col: DG.Column): Promise<DG.Widget> {
-  const widget = new PeptideSimilaritySpaceWidget(col, view ?? grok.shell.v);
+  [currentView, currentGrid, currentTable, alignedSequenceColumn] =
+    getOrDefineWIP(currentView, currentGrid, currentTable, col);
+  const widget = new PeptideSimilaritySpaceWidget(col, currentView);
   return await widget.draw();
 }
 
@@ -192,13 +208,50 @@ export async function peptideMolfile(peptide: string): Promise<DG.Widget> {
   return await grok.functions.call('Chem:molfile', {'smiles': smiles});
 }
 
+//name: Molfile
+//tags: panel, widgets
+//input: string aar { semType: aminoAcids }
+//output: widget result
+export async function peptideMolfile2(aar: string): Promise<DG.Widget> {
+  [currentView, currentGrid, currentTable, alignedSequenceColumn] =
+    getOrDefineWIP(currentView, currentGrid, currentTable, alignedSequenceColumn);
+  const peptide = alignedSequenceColumn.get(currentTable.currentRowIdx);
+  return await peptideMolfile(peptide);
+}
+
 //name: Multiple sequence alignment
 //tags: panel
 //input: column col {semType: alignedSequence}
 //output: dataframe result
 export async function multipleSequenceAlignment(col: DG.Column): Promise<DG.DataFrame> {
-  const msaCol = await runKalign(col, true);
-  const table = col.dataFrame;
-  table.columns.add(msaCol);
-  return table;
+  return await msaWidget(col);
+}
+
+//name: Substitution
+//tags: panel, widgets
+//input: dataframe table {semType: Substitution}
+//output: widget result
+export async function peptideSubstitution(table: DG.DataFrame): Promise<DG.Widget> {
+  return substTableWidget(table);
+}
+
+//name: alignedSequenceDifferenceCellRenderer
+//tags: cellRenderer, cellRenderer-alignedSequenceDifference
+//meta-cell-renderer-sem-type: alignedSequenceDifference
+//output: grid_cell_renderer result
+export function alignedSequenceDifferenceCellRenderer() {
+  return new AlignedSequenceDifferenceCellRenderer();
+}
+
+function getOrDefineWIP(
+  view?: DG.TableView, grid?: DG.Grid, dataframe?: DG.DataFrame, column?: DG.Column | null,
+): [DG.TableView, DG.Grid, DG.DataFrame, DG.Column] {
+  view ??= (grok.shell.v as DG.TableView);
+  grid ??= view.grid;
+  dataframe ??= grok.shell.t;
+  column ??= (dataframe.columns as DG.ColumnList).bySemType('alignedSequence');
+  if (column === null)
+    throw new Error('Table does not contain aligned sequence columns');
+
+  return [view, grid, dataframe, column];
 }