@datagrok/bio 2.22.6 → 2.22.7

package/src/tests/renderers-test.ts

@@ -28,7 +28,7 @@ category('renderers', () => {
   });
 
   test('long sequence performance ', async () => {
-    await performanceTest(generateLongSequence, 'Long sequences');
+    await performanceTest(() => generateLongSequence(10 ** 4), 'Long sequences');
   });
 
   test('many sequence performance', async () => {

package/src/utils/cell-renderer.ts

@@ -59,6 +59,8 @@ export function processSequence(subParts: string[]): [string[], boolean] {
 type RendererGridCellTemp = {
   [MmcrTemps.monomerPlacer]: MonomerPlacer
 }
+
+// @grok.decorators.cellRenderer({name: 'customSequenceCellRenderer', cellType: 'sequence', columnTags: 'quality=Macromolecule, units=custom'})
 export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
   private readonly seqHelper: ISeqHelper;
 

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

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
@@ -6,11 +7,13 @@ import wu from 'wu';
 import {Observable, Subject} from 'rxjs';
 
 import {IMonomerLibBase, Monomer, RGroup} from '@datagrok-libraries/bio/src/types/index';
-import {HelmAtom, HelmType, IMonomerColors, IWebEditorMonomer, MonomerType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
+import {HelmAtom, HelmType, IMonomerColors,
+  IWebEditorMonomer, MonomerType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
 import {getMonomerHandleArgs} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
 import {HelmTypes, PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
-import {HELM_OPTIONAL_FIELDS as OPT, HELM_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP} from '@datagrok-libraries/bio/src/utils/const';
+import {HELM_OPTIONAL_FIELDS as OPT, HELM_REQUIRED_FIELD as REQ,
+  HELM_RGROUP_FIELDS as RGP} from '@datagrok-libraries/bio/src/utils/const';
 import {GAP_SYMBOL, GapOriginals, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 import {Vector} from '@datagrok-libraries/utils/src/type-declarations';
 import {vectorAdd, vectorDotProduct, vectorLength} from '@datagrok-libraries/utils/src/vector-operations';
@@ -276,9 +279,19 @@ export class MonomerLibBase implements IMonomerLibBase {
     let res: any;
     if (monomer) {
       if (monomer.meta && monomer.meta.colors) {
+        // due to some weird formatting, meta.colors can be a string
+        if (typeof monomer.meta.colors === 'string') {
+          try {
+            monomer.meta.colors = JSON.parse(monomer.meta.colors);
+          } catch (e) {
+            _package.logger.error(`Bio: MonomerLib.getMonomerColors() failed to parse monomer.meta.colors: ${e}`);
+          }
+        }
         const monomerColors: { [colorSchemaName: string]: any } = monomer.meta.colors;
-        if (!(currentMonomerSchema in monomerColors)) monomerSchema = 'default';
-        res = monomerColors[monomerSchema];
+        if (monomerColors && typeof monomerColors != 'string' && !(currentMonomerSchema in monomerColors))
+          monomerSchema = 'default';
+        if (monomerColors && typeof monomerColors != 'string' && monomerSchema in monomerColors)
+          res = monomerColors[monomerSchema];
       }
 
       if (!res) {

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

@@ -5,17 +5,17 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import wu from 'wu';
-import {Observable, Subject} from 'rxjs';
+import {Observable} from 'rxjs';
 
 import {
-  HelmType, HelmAtom,
-  MonomerSetType, MonomerType, PolymerType, IWebEditorMonomer,
+  HelmType,
+  MonomerSetType, PolymerType,
 } from '@datagrok-libraries/bio/src/helm/types';
-import {IMonomerLibBase, IMonomerLib, IMonomerSet, Monomer, MonomerLibData, MonomerLibSummaryType, RGroup} from '@datagrok-libraries/bio/src/types';
-import {HELM_OPTIONAL_FIELDS as OPT, HELM_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP} from '@datagrok-libraries/bio/src/utils/const';
+import {IMonomerLibBase, IMonomerLib, Monomer,
+  MonomerLibData, MonomerLibSummaryType} from '@datagrok-libraries/bio/src/types';
 import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
 import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
-import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {getUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
 import {MonomerLibBase, MonomerLibDataType} from './monomer-lib-base';
@@ -87,7 +87,7 @@ export class MonomerLib extends MonomerLibBase implements IMonomerLib {
     if (!this._monomerSets)
       this._monomerSets = {};
     if (!(biotype in this._monomerSets)) {
-      for (const [monomerSymbol, monomer] of Object.entries(this._monomers[polymerType])) {
+      for (const [_monomerSymbol, _monomer] of Object.entries(this._monomers[polymerType])) {
 
       }
     }

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

@@ -126,18 +126,65 @@ export class DuplicateMonomerManager {
               this.settings.duplicateMonomerPreferences[polymerType] = this.settings.duplicateMonomerPreferences[polymerType] ?? {};
               this.settings.duplicateMonomerPreferences[polymerType][monomerSymbol] = monomer.lib.source;
               await setUserLibSettings(this.settings);
-              grok.shell.info(`Monomer '${monomer.name}' from source '${monomer.lib.source}' selected for symbol '${monomerSymbol}'.`);
               libManager.assignDuplicatePreferances(this.settings);
+              grok.shell.info(`Monomer '${monomer.name}' from source '${monomer.lib.source}' selected for symbol '${monomerSymbol}'.`);
             });
           }));
       }
     }
+    const setAllMonomersToSourceButton = ui.divText('Set Default');
+    setAllMonomersToSourceButton.addEventListener('click', async () => {
+      if (Object.keys(this.monomers ?? {}).length === 0) {
+        grok.shell.info('No Duplicate Monomers found');
+        return;
+      }
+      const uniqueLibSet = new Set<string>();
+      for (const polymerType in this.monomers) {
+        for (const monomerSymbol in this.monomers[polymerType]) {
+          for (const monomer of this.monomers[polymerType][monomerSymbol]) {
+            if (monomer.lib?.source)
+              uniqueLibSet.add(monomer.lib.source);
+          }
+        }
+      }
+      if (uniqueLibSet.size === 0) {
+        grok.shell.info('No Duplicate Monomers found');
+        return;
+      }
+      const uniqueLibs = Array.from(uniqueLibSet);
+      const libSelector = ui.input.choice('Default Library', {items: uniqueLibs, nullable: true});
+      ui.dialog('Set Default Monomer Source for Duplicates')
+        .add(libSelector)
+        .onOK(async () => {
+          if (!libSelector.value) {
+            grok.shell.info('No library selected');
+            return;
+          }
+          for (const polymerType in this.monomers) {
+            for (const monomerSymbol in this.monomers[polymerType]) {
+              const monomers = this.monomers[polymerType][monomerSymbol];
+              if (!monomers?.some((mon) => mon.lib?.source === libSelector.value))
+                continue;
+              this.settings.duplicateMonomerPreferences = this.settings.duplicateMonomerPreferences ?? {};
+              this.settings.duplicateMonomerPreferences[polymerType] = this.settings.duplicateMonomerPreferences[polymerType] ?? {};
+              this.settings.duplicateMonomerPreferences[polymerType][monomerSymbol] = libSelector.value;
+            }
+          }
+          await setUserLibSettings(this.settings);
+          libManager.assignDuplicatePreferances(this.settings);
+          grok.shell.info(`Default Monomer Source for Duplicates set to '${libSelector.value}'.`);
+          setTimeout(() => this.refresh(), 100);
+        })
+        .show();
+    });
+
     this.filteredMonomerRows = this.monomerCardRows;
     if (!this.vv) {
       this.vv = ui.virtualView(this.monomerCardRows.length, (i) => { this.monomerCardRows[i].render(); return this.monomerCardRows[i].root; });
       this.vv.root.classList.add('duplicate-monomers-virtual-view');
       this.searchInput = ui.input.string('Search', {placeholder: 'Monomer Symbol', value: '', onValueChanged: () => search(this.searchInput.value)});
       this.searchInput.root.style.justifyContent = 'center';
+      this.searchInput.addOptions(setAllMonomersToSourceButton);
       this.searchInput.input.style.width = '200px';
       this._root = ui.divV([ui.h1('Manage Duplicate Monomer Symbols', {style: {textAlign: 'center'}}),
         this.searchInput.root, ui.divV([this.vv.root], {style: {overflowY: 'auto', height: '100%'}})], {style: {height: '100%'}});

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

@@ -49,6 +49,89 @@ export const MONOMER_DF_COLUMNS = {
   [MONOMER_DF_COLUMN_NAMES.SOURCE]: DG.COLUMN_TYPE.STRING,
 } as const;
 
+export function getMonomersDataFrame(activeMonomerLib: IMonomerLib) {
+  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>();
+    for (const monomer of monomers) {
+      monomer.rgroups.forEach((rg) => {
+        rg.label && uniqueRgroupNamesSet.add(rg.label);
+      });
+    }
+    const uniqueRgroupNames = Array.from(uniqueRgroupNamesSet);
+    uniqueRgroupNames.sort();
+    for (const [k, v] of Object.entries(MONOMER_DF_COLUMNS)) {
+      df.columns.addNew(k, v);
+      if (k === MONOMER_DF_COLUMN_NAMES.R_GROUPS) {
+        for (const rgroupName of uniqueRgroupNames)
+          df.columns.addNew(rgroupName, DG.COLUMN_TYPE.STRING);
+      }
+    }
+      df.col(MONOMER_DF_COLUMN_NAMES.SYMBOL)!.semType = 'Monomer';
+      df.col(MONOMER_DF_COLUMN_NAMES.SYMBOL)!.setTag(MONOMER_RENDERER_TAGS.applyToBackground, 'true');
+
+
+      for (let i = 0; i < monomers.length; i++) {
+        let molSmiles = getCorrectedSmiles(monomers[i].rgroups, monomers[i].smiles, monomers[i].molfile);
+        molSmiles = fixRGroupsAsElementsSmiles(molSmiles);
+        // r-groups here might be broken, so need to make sure they are correct
+        monomers[i].rgroups = resolveRGroupInfo(monomers[i].rgroups);
+        const rgroupSmiles = uniqueRgroupNames.map((rgName) => {
+          const rgroup = monomers[i].rgroups.find((rg) => rg.label === rgName);
+          return rgroup ? getCaseInvariantValue(rgroup, HELM_RGROUP_FIELDS.CAP_GROUP_SMILES) : '';
+        });
+        let date: number | null = null;
+
+        if (monomers[i].createDate) {
+          try {
+            date = Date.parse(monomers[i].createDate!);
+          } catch (e) {
+            console.error(`Error parsing date ${monomers[i].createDate}`);
+          }
+        }
+
+
+        df.rows.setValues(i, [
+          molSmiles,
+          monomers[i].symbol,
+          monomers[i].name,
+          JSON.stringify(monomers[i].rgroups ?? []),
+          ...rgroupSmiles,
+          monomers[i].monomerType,
+          monomers[i].polymerType,
+          monomers[i].naturalAnalog,
+          monomers[i].author,
+          date,
+          monomers[i].id,
+          JSON.stringify(monomers[i].meta ?? {}),
+          monomers[i].lib?.source ?? '',
+        ]);
+        // something is wrong with setting dates, so setting it manually for now
+        try {
+          if (date)
+            df.col(MONOMER_DF_COLUMN_NAMES.CREATE_DATE)?.set(i, date, false);
+        } catch (e) {
+          console.error(`Error setting date ${monomers[i].createDate}`, e);
+        }
+      }
+      df.col(MONOMER_DF_COLUMN_NAMES.MONOMER)!.semType = DG.SEMTYPE.MOLECULE;
+      uniqueRgroupNames.forEach((rgName) => {
+        df.col(rgName)!.semType = DG.SEMTYPE.MOLECULE;
+      });
+      return df;
+  } catch (e) {
+    grok.shell.error('Error creating monomers dataframe');
+    console.error(e);
+    throw e;
+  }
+}
 
 export class MonomerManager implements IMonomerManager {
   private adjustTable() {
@@ -354,91 +437,7 @@ export class MonomerManager implements IMonomerManager {
         grok.shell.error(`Library ${fileName} not found`);
         return DG.DataFrame.create();
       }
-      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 = DG.DataFrame.create(monomers.length);
-
-      const uniqueRgroupNamesSet = new Set<string>();
-      for (const monomer of monomers) {
-        monomer.rgroups.forEach((rg) => {
-          rg.label && uniqueRgroupNamesSet.add(rg.label);
-        });
-      }
-      const uniqueRgroupNames = Array.from(uniqueRgroupNamesSet);
-      uniqueRgroupNames.sort();
-      for (const [k, v] of Object.entries(MONOMER_DF_COLUMNS)) {
-        df.columns.addNew(k, v);
-        if (k === MONOMER_DF_COLUMN_NAMES.R_GROUPS) {
-          for (const rgroupName of uniqueRgroupNames)
-            df.columns.addNew(rgroupName, DG.COLUMN_TYPE.STRING);
-        }
-      }
-      df.col(MONOMER_DF_COLUMN_NAMES.SYMBOL)!.semType = 'Monomer';
-      df.col(MONOMER_DF_COLUMN_NAMES.SYMBOL)!.setTag(MONOMER_RENDERER_TAGS.applyToBackground, 'true');
-
-
-      for (let i = 0; i < monomers.length; i++) {
-        let molSmiles = getCorrectedSmiles(monomers[i].rgroups, monomers[i].smiles, monomers[i].molfile);
-        molSmiles = fixRGroupsAsElementsSmiles(molSmiles);
-        // r-groups here might be broken, so need to make sure they are correct
-        monomers[i].rgroups = resolveRGroupInfo(monomers[i].rgroups);
-        const rgroupSmiles = uniqueRgroupNames.map((rgName) => {
-          const rgroup = monomers[i].rgroups.find((rg) => rg.label === rgName);
-          return rgroup ? getCaseInvariantValue(rgroup, HELM_RGROUP_FIELDS.CAP_GROUP_SMILES) : '';
-        });
-        let date: number | null = null;
-
-        if (monomers[i].createDate) {
-          try {
-            date = Date.parse(monomers[i].createDate!);
-          } catch (e) {
-            console.error(`Error parsing date ${monomers[i].createDate}`);
-          }
-        }
-
-
-        df.rows.setValues(i, [
-          molSmiles,
-          monomers[i].symbol,
-          monomers[i].name,
-          JSON.stringify(monomers[i].rgroups ?? []),
-          ...rgroupSmiles,
-          monomers[i].monomerType,
-          monomers[i].polymerType,
-          monomers[i].naturalAnalog,
-          monomers[i].author,
-          date,
-          monomers[i].id,
-          JSON.stringify(monomers[i].meta ?? {}),
-          monomers[i].lib?.source ?? '',
-        ]);
-        // something is wrong with setting dates, so setting it manually for now
-        try {
-          if (date)
-            df.col(MONOMER_DF_COLUMN_NAMES.CREATE_DATE)?.set(i, date, false);
-        } catch (e) {
-          console.error(`Error setting date ${monomers[i].createDate}`);
-        }
-      }
-      df.col(MONOMER_DF_COLUMN_NAMES.MONOMER)!.semType = DG.SEMTYPE.MOLECULE;
-      uniqueRgroupNames.forEach((rgName) => {
-        df.col(rgName)!.semType = DG.SEMTYPE.MOLECULE;
-      });
-      df.currentRowIdx = -1;
-      // eslint-disable-next-line rxjs/no-ignored-subscription, rxjs/no-async-subscribe
-      df.onCurrentRowChanged.subscribe(async (_) => {
-        try {
-          if (df.currentRowIdx === -1 || this._newMonomerForm.molChanged)
-            return;
-          await this.editMonomer(df.rows.get(df.currentRowIdx));
-        } catch (e) {
-          console.error(e);
-        }
-      });
+      const df = getMonomersDataFrame(this.activeMonomerLib);
       return df;
     } catch (e) {
       grok.shell.error('Error creating monomers dataframe');

package/src/viewers/web-logo-viewer.ts

@@ -31,7 +31,7 @@ import {undefinedColor} from '@datagrok-libraries/bio/src/utils/cell-renderer-mo
 
 import {AggFunc, getAgg} from '../utils/agg';
 
-import {_package, getMonomerLibHelper} from '../package';
+import {_package, PackageFunctions} from '../package';
 import {numbersWithinMaxDiff} from './utils';
 import {buildCompositionTable} from '@datagrok-libraries/bio/src/utils/composition-table';
 
@@ -463,7 +463,7 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
     this.canvas.classList.value = 'bio-wl-canvas';
     this.canvas.style.width = '100%';
 
-    getMonomerLibHelper().then((libHelper) => {
+    PackageFunctions.getMonomerLibHelper().then((libHelper) => {
       this.monomerLib = libHelper.getMonomerLib();
       this.render(WlRenderLevel.Render, 'monomerLib');
       this.subs.push(this.monomerLib.onChanged.subscribe(() => {

package/src/widgets/to-atomic-level-widget.ts

@@ -3,7 +3,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import * as OCL from 'openchemlib/full';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {_package, getSeqHelper, toAtomicLevel} from '../package';
+import {_package, PackageFunctions} from '../package';
 
 
 export async function toAtomicLevelSingle(sequence: DG.SemanticValue): Promise<{mol: string, errorText: string}> {
@@ -23,7 +23,7 @@ export async function toAtomicLevelSingle(sequence: DG.SemanticValue): Promise<{
       errorText = 'Unsupported sequence notation. please use Bio | Polytool | Convert';
       return {errorText, mol: ''};
     }
-    const seqHelper = await getSeqHelper();
+    const seqHelper = await PackageFunctions.getSeqHelper();
     const seqSh = seqHelper.getSeqHandler(sequence.cell.column);
     if (!seqSh) {
       errorText = 'No sequence handler found';
@@ -39,7 +39,7 @@ export async function toAtomicLevelSingle(sequence: DG.SemanticValue): Promise<{
     Object.entries(sequence.cell.column.tags).forEach(([key, value]) => {
       singleValCol.setTag(key, value as string);
     });
-    await toAtomicLevel(sDf, singleValCol, sequence.cell.column.meta.units === NOTATION.HELM, false);
+    await PackageFunctions.toAtomicLevel(sDf, singleValCol, sequence.cell.column.meta.units === NOTATION.HELM, false);
     if (sDf.columns.length < 2) {
       errorText = 'No structure generated';
       return {errorText, mol: ''};