@datagrok/bio 2.0.25 → 2.0.27

package/src/widgets/bio-substructure-filter.ts

@@ -14,6 +14,7 @@ import {Subject, Subscription} from 'rxjs';
 import * as C from '../utils/constants';
 import {updateDivInnerHTML} from '../utils/ui-utils';
 import {NOTATION} from '@datagrok-libraries/bio';
+import { delay } from '@datagrok-libraries/utils/src/test';
 
 export class BioSubstructureFilter extends DG.Filter {
   bioFilter: FastaFilter | SeparatorFilter | HelmFilter | null = null;
@@ -102,9 +103,7 @@ export class BioSubstructureFilter extends DG.Filter {
     } else {
       this.calculating = true;
       try {
-        this.bitset = this.notation === NOTATION.HELM ?
-          await helmSubstructureSearch(this.bioFilter!.substructure, this.column!) :
-          linearSubstructureSearch(this.bioFilter!.substructure, this.column!);
+        this.bitset = await this.bioFilter?.substrucrureSearch(this.column!)!;
         this.calculating = false;
         this.dataFrame?.rows.requestFilter();
       } finally {
@@ -127,6 +126,10 @@ abstract class BioFilterBase {
 
   set substructure(s: string) {
   }
+
+  async substrucrureSearch(column: DG.Column): Promise<DG.BitSet | null> {
+    return null;
+  }
 }
 
 class FastaFilter extends BioFilterBase {
@@ -149,9 +152,13 @@ class FastaFilter extends BioFilterBase {
   set substructure(s: string) {
     this.substructureInput.value = s;
   }
+
+  async substrucrureSearch(column: DG.Column): Promise<DG.BitSet | null> {
+    return await linearSubstructureSearch(this.substructure, column);
+  }
 }
 
-class SeparatorFilter extends FastaFilter {
+export class SeparatorFilter extends FastaFilter {
   separatorInput: DG.InputBase<string> = ui.stringInput('', '', () => {
     this.onChanged.next();
   }, {placeholder: 'Separator'});
@@ -179,9 +186,13 @@ class SeparatorFilter extends FastaFilter {
   set substructure(s: string) {
     this.substructureInput.value = s;
   }
+
+  async substrucrureSearch(column: DG.Column): Promise<DG.BitSet | null> {
+    return await linearSubstructureSearch(this.substructure, column, this.colSeparator);
+  }
 }
 
-class HelmFilter extends BioFilterBase {
+export class HelmFilter extends BioFilterBase {
   helmEditor: any;
   _filterPanel = ui.div('', {style: {cursor: 'pointer'}});
   helmSubstructure = '';
@@ -202,9 +213,9 @@ class HelmFilter extends BioFilterBase {
         .onOK(() => {
           const helmString = this.helmEditor
             .webEditor.canvas.getHelm(true).replace(/<\/span>/g, '').replace(/<span style='background:#bbf;'>/g, '');
-          this.updateFilterPanel(helmString);
           this.helmSubstructure = helmString;
-          this.onChanged.next();
+          this.updateFilterPanel(this.substructure);
+          setTimeout(() => { this.onChanged.next(); }, 10);
         }).show({modal: true, fullScreen: true});
     });
     ui.onSizeChanged(this._filterPanel).subscribe((_) => {
@@ -247,4 +258,12 @@ class HelmFilter extends BioFilterBase {
       this.helmEditor.resizeEditor(width, height);
     }
   }
+
+  async substrucrureSearch(column: DG.Column): Promise<DG.BitSet | null> {
+    ui.setUpdateIndicator(this._filterPanel, true);
+    await delay(10);
+    const res = await helmSubstructureSearch(this.substructure, column);
+    ui.setUpdateIndicator(this._filterPanel, false);
+    return res;
+  }
 }

package/src/widgets/representations.ts

@@ -1,8 +1,9 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import {getMolfilesFromSingleSeq, HELM_CORE_LIB_FILENAME} from '../utils/utils';
-import {getMacroMol} from '../utils/atomic-works';
+import {getMolfilesFromSingleSeq} from '@datagrok-libraries/bio/src/utils/monomer-utils';
+import {HELM_CORE_LIB_FILENAME} from '@datagrok-libraries/bio/src/utils/const';
+import {getMacroMol} from '@datagrok-libraries/bio/src/utils/atomic-works';
 
 /**
  * @export

package/src/const.ts

@@ -1,30 +0,0 @@
-import * as ui from 'datagrok-api/ui';
-import * as grok from 'datagrok-api/grok';
-import * as DG from 'datagrok-api/dg';
-
-export const jsonSdfMonomerLibDict = {
-  'monomerType': null,
-  'smiles': null,
-  'name': 'MonomerName',
-  'author': null,
-  'molfile': 'molecule',
-  'naturalAnalog': 'MonomerNaturalAnalogCode',
-  'rgroups': 'MonomerCaps',
-  'createDate': null,
-  'id': null,
-  'polymerType': 'MonomerType',
-  'symbol': 'MonomerCode'
-};
-
-export const RGROUP_FIELD = 'rgroups';
-export const CAP_GROUP_SMILES = 'capGroupSmiles';
-export const RGROUP_ALTER_ID = 'alternateId';
-export const CAP_GROUP_NAME = 'capGroupName';
-export const RGROUP_LABEL = 'label';
-export const MONOMER_SYMBOL = 'symbol';
-export const SDF_MONOMER_NAME = 'MonomerName';
-
-// range of hex nubers used in PepSea library to endode monomers
-export const MONOMER_ENCODE_MIN = 0x100;
-export const MONOMER_ENCODE_MAX = 0x40A;
-

package/src/monomer-library.ts

@@ -1,199 +0,0 @@
-export type MonomerEntry = {
-  mol: string,
-  type: string,
-  analogueCode: string,
-  linkages: { [link: string]: { atomNumber: number, type: string } }
-};
-export type MonomerEntries = { [name: string]: MonomerEntry };
-export type LinkData = { [link: string]: { atomNumber: number, type: string } };
-
-/** HELM associated sdf libraries with monomer processing*/
-export class MonomerLibrary {
-  static libName = 'monomerLibrary';
-
-  private monomerFields: string[] = [
-    'molecule', 'MonomerType', 'MonomerNaturalAnalogCode', 'MonomerName', 'MonomerCode', 'MonomerCaps', 'BranchMonomer',
-  ];
-
-  private library: MonomerEntries = {};
-
-  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
-   * @param {string} name
-   * @return {MonomerEntry}
-   */
-  public getMonomerEntry(name: string): MonomerEntry {
-    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
-   * @param {string} name
-   * @return {string}
-   */
-  public getMonomerMol(name: string): 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 (const link of links)
-      monomerMol = monomerMol.replace('R#', entry.linkages[link].type + ' ');
-
-
-    return monomerMol;
-  }
-
-  /** getting the list of the minomers available in library*/
-  get monomerNames(): string[] {
-    return this.monomers;
-  }
-
-  static get id(): string {
-    return MonomerLibrary.libName;
-  }
-
-  private getLinkData(mol: string, caps: string, name: string): LinkData {
-    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: LinkData = {};
-    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]: string [] };
-
-  constructor() {
-    this.dataColls = {'molecule': []};
-  }
-
-  getColls(content: string): { [_: string]: string[] } {
-    this.read(content);
-    return this.dataColls;
-  }
-
-  read(content: string): void {
-    content = content.replaceAll('\r', ''); //equalize old and new sdf standards
-    let startIndex = content.indexOf('$$$$', 0);
-    this.parse(content, 0, startIndex, (name: string, val: string): void => { // 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): number {
-    const nextStartIndex = content.indexOf('$$$$', startIndex);
-    if (nextStartIndex === -1) {
-      return -1;
-    } else {
-      this.parse(content, startIndex, nextStartIndex,
-        (name: string, val: string): void => {
-          this.dataColls[name].push(val);
-        });
-    }
-
-    if (nextStartIndex > -1)
-      return nextStartIndex + 5;
-
-
-    return nextStartIndex;
-  }
-
-  parse(content: string, start: number, end: number, handler: (name: string, val: string) => void): void {
-    const molEnd = +content.indexOf('M  END\n', start) + 7;
-    let localEnd = start;
-    this.dataColls['molecule'].push(content.substring(start, molEnd));
-
-    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 + 1);
-
-      handler(propertyName, content.substring(start, localEnd));
-      localEnd += 2;
-    }
-  }
-}

package/src/utils/utils.ts

@@ -1,135 +0,0 @@
-import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-import * as bio from '@datagrok-libraries/bio';
-
-import {
-  CAP_GROUP_NAME, CAP_GROUP_SMILES, jsonSdfMonomerLibDict, MONOMER_ENCODE_MAX, MONOMER_ENCODE_MIN, MONOMER_SYMBOL,
-  RGROUP_ALTER_ID, RGROUP_FIELD, RGROUP_LABEL, SDF_MONOMER_NAME
-} from '../const';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
-
-export const HELM_CORE_LIB_FILENAME = '/data/HELMCoreLibrary.json';
-export const HELM_CORE_LIB_MONOMER_SYMBOL = 'symbol';
-export const HELM_CORE_LIB_MOLFILE = 'molfile';
-export const HELM_CORE_FIELDS = ['symbol', 'molfile', 'rgroups', 'name'];
-
-
-export function encodeMonomers(col: DG.Column): DG.Column | null {
-  let encodeSymbol = MONOMER_ENCODE_MIN;
-  const monomerSymbolDict: { [key: string]: number } = {};
-  const units = col.tags[DG.TAGS.UNITS];
-  const sep = col.getTag(bio.TAGS.separator);
-  const splitterFunc: bio.SplitterFunc = bio.getSplitter(units, sep);
-  const encodedStringArray = [];
-  for (let i = 0; i < col.length; ++i) {
-    let encodedMonomerStr = '';
-    const monomers = splitterFunc(col.get(i));
-    monomers.forEach((m) => {
-      if (!monomerSymbolDict[m]) {
-        if (encodeSymbol > MONOMER_ENCODE_MAX) {
-          grok.shell.error(`Not enough symbols to encode monomers`);
-          return null;
-        }
-        monomerSymbolDict[m] = encodeSymbol;
-        encodeSymbol++;
-      }
-      encodedMonomerStr += String.fromCodePoint(monomerSymbolDict[m]);
-    });
-    encodedStringArray.push(encodedMonomerStr);
-  }
-  return DG.Column.fromStrings('encodedMolecules', encodedStringArray);
-}
-
-export function getMolfilesFromSeq(col: DG.Column, monomersLibObject: any[]): any[][] | null {
-  const units = col.tags[DG.TAGS.UNITS];
-  const sep = col.getTag('separator');
-  const splitterFunc: bio.SplitterFunc = bio.getSplitter(units, sep);
-  const monomersDict = createMomomersMolDict(monomersLibObject);
-  const molFiles = [];
-  for (let i = 0; i < col.length; ++i) {
-    const macroMolecule = col.get(i);
-    const monomers = splitterFunc(macroMolecule);
-    const molFilesForSeq = [];
-    for (let j = 0; j < monomers.length; ++j) {
-      if (monomers[j]) {
-        if (!monomersDict[monomers[j]]) {
-          grok.shell.warning(`Monomer ${monomers[j]} is missing in HELM library. Structure cannot be created`);
-          return null;
-        }
-        molFilesForSeq.push(JSON.parse(JSON.stringify(monomersDict[monomers[j]])));
-      }
-    }
-    molFiles.push(molFilesForSeq);
-  }
-  return molFiles;
-}
-
-export function getMolfilesFromSingleSeq(cell: DG.Cell, monomersLibObject: any[]): any[][] | null {
-  const units = cell.column.tags[DG.TAGS.UNITS];
-  const sep = cell.column!.getTag('separator');
-  const splitterFunc: bio.SplitterFunc = bio.getSplitter(units, sep);
-  const monomersDict = createMomomersMolDict(monomersLibObject);
-  const molFiles = [];
-  const macroMolecule = cell.value;
-  const monomers = splitterFunc(macroMolecule);
-  const molFilesForSeq = [];
-  for (let j = 0; j < monomers.length; ++j) {
-    if (monomers[j]) {
-      if (!monomersDict[monomers[j]]) {
-        grok.shell.warning(`Monomer ${monomers[j]} is missing in HELM library. Structure cannot be created`);
-        return null;
-      }
-      molFilesForSeq.push(JSON.parse(JSON.stringify(monomersDict[monomers[j]])));
-    }
-  }
-  molFiles.push(molFilesForSeq);
-  return molFiles;
-}
-
-export function createMomomersMolDict(lib: any[]): { [key: string]: string | any } {
-  const dict: { [key: string]: string | any } = {};
-  lib.forEach((it) => {
-    if (it['polymerType'] === 'PEPTIDE') {
-      const monomerObject: { [key: string]: any } = {};
-      HELM_CORE_FIELDS.forEach((field) => {
-        monomerObject[field] = it[field];
-      });
-      dict[it[HELM_CORE_LIB_MONOMER_SYMBOL]] = monomerObject;
-    }
-  });
-  return dict;
-}
-
-
-export function createJsonMonomerLibFromSdf(table: DG.DataFrame): any {
-  const resultLib = [];
-  for (let i = 0; i < table.rowCount; i++) {
-    const monomer: { [key: string]: string | any } = {};
-    Object.keys(jsonSdfMonomerLibDict).forEach((key) => {
-      if (key === MONOMER_SYMBOL) {
-        const monomerSymbol = table.get(jsonSdfMonomerLibDict[key], i);
-        monomer[key] = monomerSymbol === '.' ? table.get(SDF_MONOMER_NAME, i) : monomerSymbol;
-      } else if (key === RGROUP_FIELD) {
-        const rgroups = table.get(jsonSdfMonomerLibDict[key], i).split('\n');
-        const jsonRgroups: any[] = [];
-        rgroups.forEach((g: string) => {
-          const rgroup: { [key: string]: string | any } = {};
-          const altAtom = g.substring(g.lastIndexOf(']') + 1);
-          const radicalNum = g.match(/\[R(\d+)\]/)![1];
-          rgroup[CAP_GROUP_SMILES] = altAtom === 'H' ? `[*:${radicalNum}][H]` : `O[*:${radicalNum}]`;
-          rgroup[RGROUP_ALTER_ID] = altAtom === 'H' ? `R${radicalNum}-H` : `R${radicalNum}-OH`;
-          rgroup[CAP_GROUP_NAME] = altAtom === 'H' ? `H` : `OH`;
-          rgroup[RGROUP_LABEL] = `R${radicalNum}`;
-          jsonRgroups.push(rgroup);
-        });
-        monomer[key] = jsonRgroups;
-      } else {
-        if ((jsonSdfMonomerLibDict as { [key: string]: string | any })[key])
-          monomer[key] = table.get((jsonSdfMonomerLibDict as { [key: string]: string | any })[key], i);
-      }
-    });
-    resultLib.push(monomer);
-  }
-  return resultLib;
-}