@datagrok/bio 2.22.8 → 2.22.10

package/src/package.ts

@@ -70,7 +70,7 @@ import {GetRegionFuncEditor} from './utils/get-region-func-editor';
 import {sequenceToMolfile} from './utils/sequence-to-mol';
 import {detectMacromoleculeProbeDo} from './utils/detect-macromolecule-probe';
 import {getMolColumnFromHelm} from './utils/helm-to-molfile/utils';
-import {MonomerManager} from './utils/monomer-lib/monomer-manager/monomer-manager';
+import {MonomerManager, standardizeMonomerLibrary} from './utils/monomer-lib/monomer-manager/monomer-manager';
 import {calculateScoresWithEmptyValues} from './utils/calculate-scores';
 import {SeqHelper} from './utils/seq-helper/seq-helper';
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
@@ -82,6 +82,35 @@ export * from './package.g';
 // /** Avoid reassigning {@link monomerLib} because consumers subscribe to {@link IMonomerLib.onChanged} event */
 // let monomerLib: MonomerLib | null = null;
 let initBioPromise: Promise<void> | null = null;
+/** Temporary polyfill */
+
+function getDecoratorFunc() {
+  return function(args: any) {
+    return function(
+      target: any,
+      propertyKey: string,
+      descriptor: PropertyDescriptor
+    ) { };
+  };
+}
+
+// Ensure decorators object exists and polyfill missing decorators
+if (!grok.decorators)
+  (grok as any).decorators = {};
+
+const decorators = [
+  'func', 'init', 'param', 'panel', 'editor', 'demo', 'app',
+  'appTreeBrowser', 'fileHandler', 'fileExporter', 'model', 'viewer', 'filter', 'cellRenderer', 'autostart',
+  'dashboard', 'folderViewer', 'semTypeDetector', 'packageSettingsEditor', 'functionAnalysis', 'converter',
+  'fileViewer', 'model', 'treeBrowser', 'polyfill'
+];
+
+decorators.forEach((decorator) => {
+  if (!(grok.decorators as any)[decorator])
+    (grok.decorators as any)[decorator] = getDecoratorFunc();
+});
+
+/** End temporary polyfill */
 
 export class PackageFunctions {
   @grok.decorators.func({description: 'Returns an instance of the monomer library helper', outputs: [{type: 'object', name: 'result'}]})
@@ -109,6 +138,11 @@ export class PackageFunctions {
     return resWidget;
   }
 
+  @grok.decorators.func({})
+  static async standardiseMonomerLibrary(library: string): Promise<string> {
+    return await standardizeMonomerLibrary(library);
+  }
+
   // Keep for backward compatibility
   @grok.decorators.func({outputs: [{type: 'object', name: 'monomerLib'}]})
   static getBioLib(): IMonomerLib {
@@ -356,7 +390,7 @@ export class PackageFunctions {
   static async activityCliffs(
     @grok.decorators.param({options: {description: 'Input data table'}})table: DG.DataFrame,
     @grok.decorators.param({type: 'string', options: {semType: 'Macromolecule', description: 'Input data table'}}) molecules: DG.Column<string>,
-    activities: DG.Column,
+      activities: DG.Column,
     @grok.decorators.param({options: {initialValue: '80', description: 'Similarity cutoff'}}) similarity: number,
     @grok.decorators.param({type: 'string', options: {choices: ['UMAP', 't-SNE']}}) methodName: DimReductionMethods,
     @grok.decorators.param({type: 'string', options: {choices: ['Hamming', 'Levenshtein', 'Monomer chemical distance']}}) similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics,
@@ -410,30 +444,30 @@ export class PackageFunctions {
       return;
     }
 
-  const pi = DG.TaskBarProgressIndicator.create(`Running sequence activity cliffs ...`);
-  const scRes = (await new Promise<DG.Viewer | undefined>((resolve, reject) => {
-    if (table.rowCount > fastRowCount && !options?.[BYPASS_LARGE_DATA_WARNING]) {
-      ui.dialog().add(ui.divText(`Activity cliffs analysis might take several minutes.
+    const pi = DG.TaskBarProgressIndicator.create(`Running sequence activity cliffs ...`);
+    const scRes = (await new Promise<DG.Viewer | undefined>((resolve, reject) => {
+      if (table.rowCount > fastRowCount && !options?.[BYPASS_LARGE_DATA_WARNING]) {
+        ui.dialog().add(ui.divText(`Activity cliffs analysis might take several minutes.
     Do you want to continue?`))
-        .onOK(async () => {
-          runCliffs().then((res) => resolve(res)).catch((err) => reject(err));
-        })
-        .onCancel(() => { resolve(undefined); })
-        .show();
-    } else
-      runCliffs().then((res) => resolve(res)).catch((err) => reject(err));
-  }).catch((err: any) => {
-    const [errMsg, errStack] = errInfo(err);
-    _package.logger.error(errMsg, undefined, errStack);
-    throw err;
-  }).finally(() => { pi.close(); })) as DG.ScatterPlotViewer | undefined;
-  if (scRes?.props?.xColumnName && scRes?.props?.yColumnName && table.col(scRes.props.xColumnName) && table.col(scRes.props.yColumnName)) {
+          .onOK(async () => {
+            runCliffs().then((res) => resolve(res)).catch((err) => reject(err));
+          })
+          .onCancel(() => { resolve(undefined); })
+          .show();
+      } else
+        runCliffs().then((res) => resolve(res)).catch((err) => reject(err));
+    }).catch((err: any) => {
+      const [errMsg, errStack] = errInfo(err);
+      _package.logger.error(errMsg, undefined, errStack);
+      throw err;
+    }).finally(() => { pi.close(); })) as DG.ScatterPlotViewer | undefined;
+    if (scRes?.props?.xColumnName && scRes?.props?.yColumnName && table.col(scRes.props.xColumnName) && table.col(scRes.props.yColumnName)) {
     table.col(scRes.props.xColumnName)!.set(0, table.col(scRes.props.xColumnName)!.get(0)); // to trigger rendering
     table.col(scRes.props.yColumnName)!.set(0, table.col(scRes.props.yColumnName)!.get(0)); // to trigger rendering
-  }
+    }
 
-  return scRes;
-}
+    return scRes;
+  }
 
   @grok.decorators.func({
     name: 'Encode Sequences',
@@ -969,8 +1003,8 @@ export class PackageFunctions {
     return await showManageLibrariesView(false);
   }
 
-  @grok.decorators.func({name: 'Monomer Manager Tree Browser'})
-  static async manageMonomerLibrariesViewTreeBrowser(treeNode: DG.TreeViewGroup, browsePanel: DG.BrowsePanel) {
+  @grok.decorators.func({name: 'Monomer Manager Tree Browser', meta: {role: 'appTreeBrowser'}})
+  static async manageMonomerLibrariesViewTreeBrowser(treeNode: DG.TreeViewGroup) {
     const libraries = (await (await MonomerLibManager.getInstance()).getFileManager()).getValidLibraryPaths();
     libraries.forEach((libName) => {
       const nodeName = libName.endsWith('.json') ? libName.substring(0, libName.length - 5) : libName;

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

@@ -49,14 +49,29 @@ export const MONOMER_DF_COLUMNS = {
   [MONOMER_DF_COLUMN_NAMES.SOURCE]: DG.COLUMN_TYPE.STRING,
 } as const;
 
-export function getMonomersDataFrame(activeMonomerLib: IMonomerLib) {
+export async function standardiseMonomers(monomers: Monomer[]) {
+  const df = getMonomersDataFrame(monomers);
+  if (monomers.length !== df.rowCount)
+    throw new Error(`Monomers length ${monomers.length} does not match dataframe row count ${df.rowCount}`);
+  const fixedMonomers = await Promise.all(new Array(monomers.length).fill(null).map(async (_, i) => monomerFromDfRow(df.rows.get(i))));
+  return fixedMonomers;
+}
+
+/** Standardizes the monomer library
+ * warning: throws error if the library is not valid or has invalid monomers
+ */
+export async function standardizeMonomerLibrary(libraryString: string) {
+  const library: Monomer[] = JSON.parse(libraryString);
+  if (!library || !Array.isArray(library) || library.length === 0)
+    throw new Error('Invalid library format, expected an array of monomers');
+  const fixedMonomers = await standardiseMonomers(library);
+  const fixedLibrary = fixedMonomers.map((m) => ({...m, lib: undefined, wem: undefined}));
+  const libraryStringFixed = JSON.stringify(fixedLibrary, null, 2);
+  return libraryStringFixed;
+}
+
+export function getMonomersDataFrame(monomers: Monomer[]) {
   try {
-    const ploymerTypes = activeMonomerLib.getPolymerTypes();
-    const monomers = ploymerTypes.flatMap((polymerType) => {
-      return activeMonomerLib!.getMonomerSymbolsByType(polymerType).map((symbol) => {
-        return activeMonomerLib!.getMonomer(polymerType, symbol)!;
-      });
-    });
     const df = DG.DataFrame.create(monomers.length);
 
     const uniqueRgroupNamesSet = new Set<string>();
@@ -437,7 +452,14 @@ export class MonomerManager implements IMonomerManager {
         grok.shell.error(`Library ${fileName} not found`);
         return DG.DataFrame.create();
       }
-      const df = getMonomersDataFrame(this.activeMonomerLib);
+
+      const ploymerTypes = this.activeMonomerLib.getPolymerTypes();
+      const monomers = ploymerTypes.flatMap((polymerType) => {
+        return this.activeMonomerLib!.getMonomerSymbolsByType(polymerType).map((symbol) => {
+          return this.activeMonomerLib!.getMonomer(polymerType, symbol)!;
+        });
+      });
+      const df = getMonomersDataFrame(monomers);
       return df;
     } catch (e) {
       grok.shell.error('Error creating monomers dataframe');