@datagrok/bio 2.15.3 → 2.15.6

package/src/utils/helm-to-molfile/converter/types.ts

@@ -11,13 +11,3 @@ export type PositionInBonds = {
   nodeIdx: number,
 }
 
-export type MonomerMap = { position: number, symbol: string, atoms: number[], bonds: number[] };
-
-export class MolfileWithMap {
-  constructor(
-    public readonly molfile: string,
-    public readonly monomers: MonomerMap[]
-  ) {}
-
-  static empty() { return new MolfileWithMap('', []); }
-}

package/src/utils/helm-to-molfile/utils.ts

@@ -2,27 +2,30 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {_package} from '../../package';
+import {IMonomerLibBase} from '@datagrok-libraries/bio/src/types';
+
 import {SeqHelper} from '../seq-helper';
 
+import {_package, getMonomerLib} from '../../package';
 
 /** Translate HELM column into molfile column and append to the dataframe */
 export async function getMolColumnFromHelm(
-  df: DG.DataFrame, helmCol: DG.Column<string>, chiralityEngine: boolean = true
+  df: DG.DataFrame, helmCol: DG.Column<string>, chiralityEngine: boolean = true, monomerLib: IMonomerLibBase
 ): Promise<DG.Column<string>> {
   const seqHelper = await SeqHelper.getInstance();
-  const converter = seqHelper.getHelmToMolfileConverter(df, helmCol);
-  const molCol = converter.convertToRdKitBeautifiedMolfileColumn(chiralityEngine, _package.rdKitModule);
+  const converter = seqHelper.getHelmToMolfileConverter(monomerLib);
+  const molCol = converter.convertToRdKitBeautifiedMolfileColumn(helmCol, chiralityEngine, _package.rdKitModule, monomerLib);
   molCol.semType = DG.SEMTYPE.MOLECULE;
   return molCol;
 }
 
 export async function getSmilesColumnFromHelm(
-  df: DG.DataFrame, helmCol: DG.Column<string>
+  helmCol: DG.Column<string>
 ): Promise<DG.Column<string>> {
   const seqHelper = await SeqHelper.getInstance();
-  const converter = seqHelper.getHelmToMolfileConverter(df, helmCol);
-  const smilesCol = converter.convertToSmiles(_package.rdKitModule);
+  const monomerLib = getMonomerLib();
+  const converter = seqHelper.getHelmToMolfileConverter(monomerLib);
+  const smilesCol = converter.convertToSmiles(helmCol);
   smilesCol.semType = DG.SEMTYPE.MOLECULE;
   return smilesCol;
 }

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

@@ -0,0 +1,18 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
+import {MonomerLibSummaryType} from '@datagrok-libraries/bio/src/types/index';
+
+export const LIB_PATH = 'System:AppData/Bio/monomer-libraries/';
+export const SETS_PATH: string = 'System:AppData/Bio/monomer-sets/';
+
+export const HELM_JSON_SCHEMA_PATH = 'System:AppData/Bio/tests/libraries/HELMmonomerSchema.json';
+
+export const LIB_SETTINGS_FOR_TESTS: UserLibSettings =
+  {explicit: ['HELMCoreLibrary.json', 'polytool-lib.json'], exclude: [], duplicateMonomerPreferences: {}};
+
+/** Summary for settings {@link LIB_SETTINGS_FOR_TESTS} */
+export const monomerLibForTestsSummary: MonomerLibSummaryType = {'PEPTIDE': 326, 'RNA': 383, 'CHEM': 0};
+

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

@@ -7,7 +7,7 @@ import {delay} from '@datagrok-libraries/utils/src/test';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
 import {IMonomerLib, IMonomerSet} from '@datagrok-libraries/bio/src/types';
 import {
-  getUserLibSettings, setUserLibSettings, LIB_PATH, SETS_PATH
+  getUserLibSettings, setUserLibSettings,
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {
@@ -18,6 +18,7 @@ import {MonomerLib} from './monomer-lib';
 import {MonomerSet} from './monomer-set';
 import {MonomerLibFileManager} from './library-file-manager/file-manager';
 import {MonomerLibFileEventManager} from './library-file-manager/event-manager';
+import {LIB_PATH, LIB_SETTINGS_FOR_TESTS, SETS_PATH} from './consts';
 
 import {_package} from '../../package';
 
@@ -34,7 +35,7 @@ export class MonomerLibManager implements IMonomerLibHelper {
 
   public get eventManager(): IMonomerLibFileEventManager { return this._eventManager; }
 
-  public async awaitLoaded(timeout: number = 3000): Promise<void> {
+  public async awaitLoaded(timeout: number = 5000): Promise<void> {
     return await Promise.race([
       (async () => {
         const fileManager = await this.getFileManager();
@@ -47,7 +48,7 @@ export class MonomerLibManager implements IMonomerLibHelper {
       })(),
     ]).then((res) => {
       if (!res)
-        throw new Error(`Loading monomer libraries is timeout ${timeout} ms.`);
+        throw new Error(`Loading monomer libraries timeout ${timeout} ms.`);
     });
   }
 
@@ -267,6 +268,15 @@ export class MonomerLibManager implements IMonomerLibHelper {
     return invalidNames;
   }
 
+  // -- Settings --
+
+  /** Changes userLibSettings set only HELMCoreLibrary.json, polytool-lib.json */
+  async loadMonomerLibForTests(): Promise<void> {
+    await setUserLibSettings(LIB_SETTINGS_FOR_TESTS);
+    await this.awaitLoaded();
+    await this.loadMonomerLib(true); // load default libraries
+  }
+
   // -- Instance singleton --
   public static async getInstance(): Promise<MonomerLibManager> {
     let res = window.$monomerLibHelperPromise;

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

@@ -8,7 +8,6 @@ import {JSONSchemaType} from 'ajv';
 import {MonomerType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
 import {IMonomerLib, IMonomerLinkData, IMonomerSet, Monomer} from '@datagrok-libraries/bio/src/types';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
-import {LIB_PATH, SETS_PATH} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {
   HELM_REQUIRED_FIELD as REQ,
 } from '@datagrok-libraries/bio/src/utils/const';
@@ -17,10 +16,10 @@ import {
 } from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
 import {MonomerLib} from '../monomer-lib';
-import {HELM_JSON_SCHEMA_PATH} from './consts';
 import {MonomerLibFileEventManager} from './event-manager';
 import {MonomerLibFileValidator} from './file-validator';
 import {MonomerSet, MonomerSetPlaceholder} from '../monomer-set';
+import {HELM_JSON_SCHEMA_PATH, LIB_PATH, SETS_PATH} from '../consts';
 
 import {_package} from '../../../package';
 

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

@@ -0,0 +1,68 @@
+import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {Helm} from '../helm-to-molfile/converter/helm';
+import {HelmType} from '@datagrok-libraries/bio/src/helm/types';
+
+/**
+ * MonomerColors class from HelmWebEditor for natural monomers
+ */
+export const naturalMonomerColors = {
+  [HelmTypes.BASE]: {
+    A: "#A0A0FF",
+    G: "#FF7070",
+    T: "#A0FFA0",
+    C: "#FF8C4B",
+    U: "#FF8080"
+  },
+
+  [HelmTypes.NUCLEOTIDE]: {
+    A: "#A0A0FF",
+    G: "#FF7070",
+    T: "#A0FFA0",
+    C: "#FF8C4B",
+    U: "#FF8080"
+  },
+
+  [HelmTypes.LINKER]: {
+    P: "#9aa5e1",
+    p: "#9aa5e1"
+  },
+
+  [HelmTypes.SUGAR]: {
+    R: "#7a85c1",
+    r: "#7a85c1",
+    // TODO: deoxyribose
+  },
+
+  [HelmTypes.AA]: {
+    A: "#C8C8C8",
+    R: "#145AFF",
+    N: "#00DCDC",
+    D: "#E60A0A",
+    C: "#E6E600",
+    E: "#00DCDC",
+    Q: "#E60A0A",
+    G: "#EBEBEB",
+    H: "#8282D2",
+    I: "#0F820F",
+    L: "#0F820F",
+    K: "#145AFF",
+    M: "#E6E600",
+    F: "#3232AA",
+    P: "#DC9682",
+    S: "#FA9600",
+    T: "#FA9600",
+    W: "#B45AB4",
+    Y: "#3232AA",
+    V: "#0F820F"
+  },
+
+  [HelmTypes.CHEM]: {
+    R: "#eeeeee",
+  },
+
+  [HelmTypes.BLOB]: {
+    B: "#999999",
+    G: "#e2e2e2"
+  }
+};
+

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

@@ -0,0 +1,165 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import wu from 'wu';
+
+import {IMonomerLibBase, Monomer, RGroup} from '@datagrok-libraries/bio/src/types/index';
+import {HelmAtom, HelmType, 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_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP} from '@datagrok-libraries/bio/src/utils/const';
+import {GapOriginals, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+
+import {AmbiguousWebEditorMonomer, GapWebEditorMonomer, MissingWebEditorMonomer} from './web-editor-monomer-dummy';
+import {LibraryWebEditorMonomer} from './web-editor-monomer-of-library';
+
+import {_package} from '../../package';
+import {Observable, Subject} from 'rxjs';
+
+const monomerRe = /[\w()]+/;
+//** Do not mess with monomer symbol with parenthesis enclosed in square brackets */
+const ambMonomerRe = RegExp(String.raw`\(${monomerRe}(,${monomerRe})+\)`);
+
+export type MonomerLibDataType = { [polymerType: string]: { [monomerSymbol: string]: Monomer } };
+
+export class MonomerLibBase implements IMonomerLibBase {
+  protected _onChanged = new Subject<any>();
+
+  get onChanged(): Observable<any> { return this._onChanged; }
+
+  constructor(
+    protected _monomers: MonomerLibDataType,
+  ) {}
+
+  /** Creates missing {@link Monomer} */
+  addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
+    let mSet = this._monomers[polymerType];
+    if (!mSet)
+      mSet = this._monomers[polymerType] = {};
+
+    let monomerName: string = monomerSymbol;
+    if (monomerSymbol === GapOriginals[NOTATION.HELM])
+      monomerName = 'Gap';
+    else if (polymerType === PolymerTypes.PEPTIDE && monomerSymbol === 'X')
+      monomerName = 'Any';
+    else if (polymerType === PolymerTypes.RNA && monomerSymbol === 'N')
+      monomerName = 'Any';
+
+    const m = mSet[monomerSymbol] = {
+      [REQ.SYMBOL]: monomerSymbol,
+      [REQ.NAME]: monomerName,
+      [REQ.MOLFILE]: '',
+      [REQ.AUTHOR]: 'MISSING',
+      [REQ.ID]: -1,
+      [REQ.RGROUPS]:
+        wu.count(1).take(9).map((i) => {
+          return {
+            /* eslint-disable no-multi-spaces */
+            // Samples                        //  PEPTIDE     RNA
+            [RGP.CAP_GROUP_SMILES]: '',       // '[*:1][H]'  '[*:1][H]'
+            [RGP.ALTERNATE_ID]: '',           // 'R1-H'      'R1-H'
+            [RGP.CAP_GROUP_NAME]: '',         // 'H'         'H'
+            [RGP.LABEL]: `R${i.toString()}`,  // 'R1'        'R1'
+            /* eslint-enable no-multi-spaces */
+          } as RGroup;
+        }).toArray(),
+      [REQ.SMILES]: '',
+      [REQ.POLYMER_TYPE]: polymerType,
+      [REQ.MONOMER_TYPE]: undefined as unknown as MonomerType, // TODO: Can we get monomerType from atom of POM
+      [REQ.CREATE_DATE]: null,
+    } as Monomer;
+    return m;
+  }
+
+  getMonomer(polymerType: PolymerType | null, argMonomerSymbol: string): Monomer | null {
+    const logPrefix = `Bio: MonomerLib.getMonomer()`;
+    // Adjust RNA's 'R' for ribose to 'r' and 'P' for phosphate to 'p' for case-sensitive monomer names.
+    // There are uppercase 'R' and 'P' at RNA samples in test data 'helm2.csv' but lowercase in HELMCoreLibrary.json
+    let monomerSymbol = argMonomerSymbol;
+    if (polymerType == 'RNA' && monomerSymbol == 'R')
+      monomerSymbol = 'r';
+    if (polymerType == 'RNA' && monomerSymbol == 'P')
+      monomerSymbol = 'p';
+
+    let res: Monomer | null = null;
+
+    if (!polymerType) {
+      _package.logger.warning(`${logPrefix} symbol '${argMonomerSymbol}', polymerType not specified.`);
+      // Assume any polymer type
+      for (const [_polymerType, dict] of Object.entries(this._monomers)) {
+        res = dict[monomerSymbol];
+        if (res) break;
+      }
+    } else {
+      const dict = this._monomers[polymerType];
+      res = dict ? dict[monomerSymbol] : null;
+    }
+    return res;
+  }
+
+  /** Substitutes {@link org.helm.webeditor.Monomers.getMonomer()} */
+  getWebEditorMonomer(a: HelmAtom | HelmType, argName?: string): IWebEditorMonomer | null {
+    const [biotype, elem] = getMonomerHandleArgs(a, argName);
+    const pt = helmTypeToPolymerType(biotype);
+
+    /** Get or create {@link Monomer} object (in case it is missing in monomer library current config) */
+    let m: Monomer | null = this.getMonomer(pt, elem);
+    if (m && biotype == HelmTypes.LINKER && m[REQ.RGROUPS].length != 2) {
+      // Web Editor expects null
+      return null;
+    }
+    if (m && biotype == HelmTypes.SUGAR && m[REQ.RGROUPS].length != 3) {
+      // Web Editor expects null
+      return null;
+    }
+    if (!m /* && biotype != HelmTypes.LINKER*/)
+      m = this.addMissingMonomer(pt, elem);
+
+    /** Get or create {@link org,helm.WebEditorMonomer} */
+    let resWem: IWebEditorMonomer | null = m.wem ?? null;
+    if (!resWem) {
+      if (elem === '*')
+        resWem = m.wem = new GapWebEditorMonomer(biotype, elem);
+      else if (
+        (biotype === 'HELM_NUCLETIDE' && elem === 'N') ||
+        (biotype === 'HELM_AA' && elem === 'X') ||
+        (biotype === 'HELM_CHEM' && false) || // TODO: Ambiguous monomer for CHEM
+        ambMonomerRe.test(elem) // e.g. (A,R,_)
+      )
+        resWem = m.wem = new AmbiguousWebEditorMonomer(biotype, elem);
+      else if (!m.lib)
+        resWem = m.wem = new MissingWebEditorMonomer(biotype, elem);
+
+      if (!resWem)
+        resWem = m.wem = LibraryWebEditorMonomer.fromMonomer(biotype, m, this);
+    }
+
+    return resWem!;
+  }
+
+  getRS(smiles: string): { [r: string]: string } {
+    const newS = smiles.match(/(?<=\[)[^\][]*(?=])/gm);
+    const res: { [name: string]: string } = {};
+    let el = '';
+    let digit;
+    if (!!newS) {
+      for (let i = 0; i < newS.length; i++) {
+        if (newS[i] != null) {
+          if (/\d/.test(newS[i])) {
+            digit = newS[i][newS[i].length - 1];
+            newS[i] = newS[i].replace(/[0-9]/g, '');
+            for (let j = 0; j < newS[i].length; j++) {
+              if (newS[i][j] != ':')
+                el += newS[i][j];
+            }
+            res['R' + digit] = el;
+            el = '';
+          }
+        }
+      }
+    }
+    return res;
+  }
+}

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

@@ -7,40 +7,42 @@ import * as DG from 'datagrok-api/dg';
 import wu from 'wu';
 import {Observable, Subject} from 'rxjs';
 
-import {HelmType, MonomerSetType, MonomerType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
-import {IMonomerLib, IMonomerSet, Monomer, MonomerLibSummaryType, RGroup} from '@datagrok-libraries/bio/src/types';
-import {HELM_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP} from '@datagrok-libraries/bio/src/utils/const';
+import {
+  HelmType, HelmAtom,
+  MonomerSetType, MonomerType, PolymerType, IWebEditorMonomer,
+} 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 {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
-import {GapOriginals} from '@datagrok-libraries/bio/src/utils/seq-handler';
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
 import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
+import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
-import '../../../css/cell-renderer.css';
+import {MonomerLibBase, MonomerLibDataType} from './monomer-lib-base';
 
 import {_package} from '../../package';
-import {getUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
-import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
+
+import '../../../css/cell-renderer.css';
 
 /** Wrapper for monomers obtained from different sources. For managing monomere
  * libraries, use MolfileHandler class instead */
-export class MonomerLib implements IMonomerLib {
-  private _monomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer } } = {};
-  private _onChanged = new Subject<any>();
+export class MonomerLib extends MonomerLibBase implements IMonomerLib {
   private _duplicateMonomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer[] } } = {};
   public get duplicateMonomers(): { [polymerType: string]: { [monomerSymbol: string]: Monomer[] } } {
     return this._duplicateMonomers;
   }
+
   private _duplicatesHandled = true;
   public get duplicatesHandled() { return this._duplicatesHandled; }
+
   private duplicatesNotified: boolean = false;
 
   constructor(
-    monomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer } },
+    monomers: MonomerLibDataType,
     public readonly source: string | undefined = undefined,
     public readonly error: string | undefined = undefined,
   ) {
-    this._monomers = monomers;
+    super(monomers);
     for (const [_monomerType, monomersOfType] of Object.entries(this._monomers)) {
       for (const [_monomerSymbol, monomer] of Object.entries(monomersOfType))
         monomer.lib = this;
@@ -56,46 +58,6 @@ export class MonomerLib implements IMonomerLib {
     return resJSON;
   }
 
-  /** Creates missing {@link Monomer} */
-  addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
-    let mSet = this._monomers[polymerType];
-    if (!mSet)
-      mSet = this._monomers[polymerType] = {};
-
-    let monomerName: string = monomerSymbol;
-    if (monomerSymbol === GapOriginals[NOTATION.HELM])
-      monomerName = 'Gap';
-    else if (polymerType === PolymerTypes.PEPTIDE && monomerSymbol === 'X')
-      monomerName = 'Any';
-    else if (polymerType === PolymerTypes.RNA && monomerSymbol === 'N')
-      monomerName = 'Any';
-
-    const m = mSet[monomerSymbol] = {
-      [REQ.SYMBOL]: monomerSymbol,
-      [REQ.NAME]: monomerName,
-      [REQ.MOLFILE]: '',
-      [REQ.AUTHOR]: 'MISSING',
-      [REQ.ID]: -1,
-      [REQ.RGROUPS]:
-        wu.count(1).take(9).map((i) => {
-          return {
-            /* eslint-disable no-multi-spaces */
-            // Samples                        //  PEPTIDE     RNA
-            [RGP.CAP_GROUP_SMILES]: '',       // '[*:1][H]'  '[*:1][H]'
-            [RGP.ALTERNATE_ID]: '',           // 'R1-H'      'R1-H'
-            [RGP.CAP_GROUP_NAME]: '',         // 'H'         'H'
-            [RGP.LABEL]: `R${i.toString()}`,  // 'R1'        'R1'
-            /* eslint-enable no-multi-spaces */
-          } as RGroup;
-        }).toArray(),
-      [REQ.SMILES]: '',
-      [REQ.POLYMER_TYPE]: polymerType,
-      [REQ.MONOMER_TYPE]: undefined as unknown as MonomerType, // TODO: Can we get monomerType from atom of POM
-      [REQ.CREATE_DATE]: null,
-    } as Monomer;
-    return m;
-  }
-
   getMonomer(polymerType: PolymerType | null, argMonomerSymbol: string): Monomer | null {
     const logPrefix = `Bio: MonomerLib.getMonomer()`;
     // Adjust RNA's 'R' for ribose to 'r' and 'P' for phosphate to 'p' for case-sensitive monomer names.
@@ -117,7 +79,7 @@ export class MonomerLib implements IMonomerLib {
       }
     } else {
       const dict = this._monomers[polymerType];
-      res = dict ? dict[monomerSymbol] : null;
+      res = dict?.[monomerSymbol] ?? null;
     }
     return res;
   }
@@ -181,10 +143,6 @@ export class MonomerLib implements IMonomerLib {
     return monomers.map((monomer) => monomer?.symbol!);
   }
 
-  get onChanged(): Observable<any> {
-    return this._onChanged;
-  }
-
   private _updateLibInt(lib: IMonomerLib): void {
     const typesNew = lib.getPolymerTypes();
     const types = this.getPolymerTypes();
@@ -285,19 +243,8 @@ export class MonomerLib implements IMonomerLib {
     return resStr;
   }
 
-  getTooltip(polymerType: PolymerType, monomerSymbol: string): HTMLElement {
-    // getTooltip(monomer: Monomer): HTMLElement;
-    // getTooltip(monomerOrPolymerType: string | Monomer, symbol?: string): HTMLElement {
-    //   let polymerType: string;
-    //   let monomerSymbol: string;
-    //   if (typeof monomerOrPolymerType === 'string' || monomerOrPolymerType instanceof String) {
-    //     polymerType = monomerOrPolymerType as string;
-    //     monomerSymbol = symbol!;
-    //   } else {
-    //     const m = monomerOrPolymerType as Monomer;
-    //     polymerType = m[HELM_REQUIRED_FIELD.POLYMER_TYPE];
-    //     monomerSymbol = m[HELM_REQUIRED_FIELD.SYMBOL];
-    //   }
+  getTooltip(biotype: HelmType, monomerSymbol: string): HTMLElement {
+    const polymerType = helmTypeToPolymerType(biotype);
     const res = ui.div([], {classes: 'ui-form ui-tooltip'});
     const monomer = this.getMonomer(polymerType, monomerSymbol);
     if (monomer) {
@@ -336,4 +283,29 @@ export class MonomerLib implements IMonomerLib {
     }
     return res;
   }
+
+  override(data: MonomerLibData): IMonomerLibBase {
+    return new OverriddenMonomerLib(data, this);
+  }
+}
+
+class OverriddenMonomerLib extends MonomerLibBase {
+  constructor(
+    private readonly data: MonomerLibData,
+    private readonly base: MonomerLibBase
+  ) {
+    super(data);
+  }
+
+  get onChanged(): Observable<any> { return this.base.onChanged; }
+
+  addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
+    return this.base.addMissingMonomer(polymerType, monomerSymbol);
+  }
+
+  getMonomer(polymerType: PolymerType | null, monomerSymbol: string): Monomer | null {
+    const dataMonomer = this.data[polymerType as string]?.[monomerSymbol];
+    const resMonomer = dataMonomer ?? this.base.getMonomer(polymerType, monomerSymbol);
+    return resMonomer;
+  }
 }

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

@@ -8,12 +8,12 @@ import * as DG from 'datagrok-api/dg';
 import {IMonomerManager, INewMonomerForm} from '@datagrok-libraries/bio/src/utils/monomer-ui';
 import {IMonomerLib, Monomer, RGroup} from '@datagrok-libraries/bio/src/types';
 import {DUMMY_MONOMER, HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
-import {LIB_PATH} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {ItemsGrid} from '@datagrok-libraries/utils/src/items-grid';
 import {mostSimilarNaturalAnalog} from '@datagrok-libraries/bio/src/utils/macromolecule/monomers';
 import {PolymerType, MonomerType} from '@datagrok-libraries/bio/src/helm/types';
 
 import {MonomerLibManager} from '../lib-manager';
+import {LIB_PATH} from '../consts';
 
 import '../../../../css/monomer-manager.css';