@datagrok/bio 2.14.2 → 2.15.0

package/src/tests/seq-handler-get-helm-tests.ts

@@ -0,0 +1,88 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {after, before, category, expect, test} from '@datagrok-libraries/utils/src/test';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
+
+category('SeqHandler: getHelm', () => {
+  let monomerLibHelper: IMonomerLibHelper;
+  let userLibSettings: UserLibSettings; // backup
+
+  before(async () => {
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibSettings = await getUserLibSettings();
+
+    // Test 'helm' requires default monomer library loaded
+    await setUserLibSettingsForTests();
+    await monomerLibHelper.loadMonomerLib(true); // load default libraries
+  });
+
+  after(async () => {
+    await setUserLibSettings(userLibSettings);
+    await monomerLibHelper.loadMonomerLib(true); // load user settings libraries
+  });
+
+
+  const tests: {
+    [testName: string]: {
+      src: {
+        seq: string, notation: NOTATION, separator?: string
+      }, tgt: { helm: string }
+    }
+  } = {
+    'fasta': {
+      src: {seq: 'MDYKETMDYKET', notation: NOTATION.FASTA},
+      tgt: {helm: 'PEPTIDE1{M.D.Y.K.E.T.M.D.Y.K.E.T}$$$$'},
+    },
+    'separator': {
+      src: {seq: 'M-D-Y-K-E-T-M-D-Y-K-E-T', notation: NOTATION.SEPARATOR, separator: '-'},
+      tgt: {helm: 'PEPTIDE1{M.D.Y.K.E.T.M.D.Y.K.E.T}$$$$'},
+    },
+    'helm': {
+      src: {seq: 'PEPTIDE1{M.D.Y.K.E.T}$$$$', notation: NOTATION.HELM},
+      tgt: {helm: 'PEPTIDE1{M.D.Y.K.E.T}$$$$'},
+    },
+    'helm-cyclic': {
+      src: {seq: 'PEPTIDE1{M.D.Y.K.E.T}$PEPTIDE1,PEPTIDE1,6:R2-1:R1$$$V2.0', notation: NOTATION.HELM},
+      tgt: {helm: 'PEPTIDE1{M.D.Y.K.E.T}$PEPTIDE1,PEPTIDE1,6:R2-1:R1$$$V2.0'}
+    },
+
+    // TODO: Add tests for cyclized and dimerized
+    // 'separator-cyclized': {
+    //   src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI', notation: NOTATION.SEPARATOR, separator: '-',},
+    //   tgt: {helm: 'PEPTIDE1{[R].[F].[C].[T].[G].[H].[F].[Y].[P].[C].[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$'}
+    // },
+    // 'separator-dimerized': {
+    //   src: {seq: '(#2)C-{R-F-C(2)-T-G-H-F-Y-P-C(2)-Mei}', notation: NOTATION.SEPARATOR, separator: '-',},
+    //   tgt: {helm: ''}
+    // },
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(testName, async () => {
+      await _testSeqHandlerGetHelm(testData.src.seq, testData.src.notation, testData.src.separator, testData.tgt.helm);
+    });
+  }
+
+  async function _testSeqHandlerGetHelm(
+    srcSeq: string, srcNotation: NOTATION, srcSeparator: string | undefined, tgtHelm: string
+  ): Promise<void> {
+    const seqCol = DG.Column.fromStrings('seq', [srcSeq]);
+    const df = DG.DataFrame.fromColumns([seqCol]);
+    // seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    // seqCol.setTag(DG.TAGS.UNITS, srcNotation);
+    // seqCol.setTag(TAGS.alphabet, 'PT');
+    // if (srcSeparator) seqCol.setTag(TAGS.separator, srcSeparator);
+    await grok.data.detectSemanticTypes(df);
+
+    const sh = SeqHandler.forColumn(seqCol);
+    const resHelm = await sh.getHelm(0, false);
+    expect(resHelm, tgtHelm);
+  }
+});

package/src/tests/sequence-space-test.ts

@@ -14,9 +14,10 @@ category('sequenceSpace', async () => {
   let testHelmWithEmptyRowsTableView: DG.TableView;
 
   test('sequenceSpaceOpens', async () => {
-    testFastaDf = await readDataframe(
-      DG.Test.isInBenchmark ? 'test/peptides_motif-with-random_10000.csv' : 'tests/100_3_clustests.csv',
-    );
+    const testData = !DG.Test.isInBenchmark ?
+      {fileName: 'tests/100_3_clustests.csv'} :
+      {fileName: 'tests/peptides_motif-with-random_10000.csv'};
+    testFastaDf = await readDataframe(testData.fileName);
     testFastaTableView = grok.shell.addTableView(testFastaDf);
     await _testSequenceSpaceReturnsResult(testFastaDf, DimReductionMethods.UMAP, 'sequence');
     //grok.shell.closeTable(testFastaDf);

package/src/tests/to-atomic-level-tests.ts

@@ -18,6 +18,7 @@ import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
 import {toAtomicLevel} from '../package';
 import {_package} from '../package-test';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 
 const appPath = 'System:AppData/Bio';
 const fileSource = new DG.FileSource(appPath);
@@ -216,6 +217,7 @@ PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.Thr_PO3H2.Aca.Tyr
 async function _testToAtomicLevel(
   df: DG.DataFrame, seqColName: string = 'seq', monomerLibHelper: IMonomerLibHelper
 ): Promise<DG.Column | null> {
+  const rdKitModule = await getRdKitModule();
   const seqCol: DG.Column<string> = df.getCol(seqColName);
   const monomerLib: IMonomerLib = monomerLibHelper.getMonomerLib();
   const res = await _toAtomicLevel(df, seqCol, monomerLib);

package/src/tests/to-atomic-level-ui-tests.ts

@@ -0,0 +1,74 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+import {after, before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
+import {sequenceToMolfile} from '../utils/sequence-to-mol';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
+
+import {ConverterFunc} from './types';
+import {_package} from '../package';
+
+category('toAtomicLevel-ui', () => {
+
+  let monomerLibHelper: IMonomerLibHelper;
+  let userLibSettings: UserLibSettings;
+  let helmHelper: IHelmHelper;
+
+  before(async () => {
+    helmHelper = await getHelmHelper(); // init Helm package
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibSettings = await getUserLibSettings();
+
+    // Test 'helm' requires default monomer library loaded
+    await setUserLibSettingsForTests();
+    await monomerLibHelper.loadMonomerLib(true); // load default libraries
+  });
+
+  after(async () => {
+    // UserDataStorage.put() replaces existing data
+    await setUserLibSettings(userLibSettings);
+    await monomerLibHelper.loadMonomerLib(true); // load user settings libraries
+  });
+  const fastaCsv = `seq
+MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW
+MIEVFLFGIVLGLIPITLAGLFVTAYLQYRRGDQLDL
+MMELVLKTIIGPIVVGVVLRIVDKWLNKDK
+`;
+  const helmCsv = `seq
+PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2.Aca.D-Tyr_Et.Aze.dV.E.N.dV.Phe_4Me}$$$$
+PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2.Aca.meM.D-Chg.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$$
+PEPTIDE1{meI.Aca.N.T.dK.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.D-Cit.N.D-Orn.D-aThr.Phe_4Me}$$$$
+`;
+
+  test('toAtomicLevel-fasta-linear', async () => {
+    const df = DG.DataFrame.fromCsv(fastaCsv);
+    await grok.data.detectSemanticTypes(df);
+    const seqCol = df.getCol('seq');
+    await _testToAtomicLevelFunc(df, seqCol, false);
+  });
+
+  test('toAtomicLevel-fasta-nonlinear', async () => {
+    const df = DG.DataFrame.fromCsv(fastaCsv);
+    await grok.data.detectSemanticTypes(df);
+    const seqCol = df.getCol('seq');
+    await _testToAtomicLevelFunc(df, seqCol, true);
+  });
+
+  test('toAtomicLevel-helm', async () => {
+    const df = DG.DataFrame.fromCsv(helmCsv);
+    await grok.data.detectSemanticTypes(df);
+    const seqCol = df.getCol('seq');
+    await _testToAtomicLevelFunc(df, seqCol, true);
+  });
+
+  async function _testToAtomicLevelFunc(
+    table: DG.DataFrame, seqCol: DG.Column<string>, nonlinear: boolean
+  ): Promise<void> {
+    const molCol = await sequenceToMolfile(table, seqCol, nonlinear, monomerLibHelper.getMonomerLib());
+    expect(molCol!.semType, DG.SEMTYPE.MOLECULE);
+  }
+});

package/src/utils/cell-renderer.ts

@@ -1,3 +1,6 @@
+/* eslint-disable max-lines */
+/* eslint-disable max-params */
+/* eslint-disable max-lines-per-function */
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';

package/src/utils/convert.ts

@@ -65,7 +65,7 @@ export function convert(col?: DG.Column): void {
   };
 
   const targetColumnInput = ui.input.column('Column', {table: grok.shell.t, value: srcCol,
-    onValueChanged: (input) => toggleColumn(input.value)});
+    onValueChanged: (value) => toggleColumn(value)});
 
   const separatorArray = ['-', '.', '/'];
   let filteredNotations = notations.filter((e) => e !== currentNotation);
@@ -85,7 +85,7 @@ export function convert(col?: DG.Column): void {
   // set correct visibility on init
   toggleSeparator();
 
-  targetNotationInput.onChanged(() => {
+  targetNotationInput.onChanged.subscribe(() => {
     toggleSeparator();
   });
 

package/src/utils/cyclized.ts

@@ -1,3 +1,7 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
 import {GAP_SYMBOL, INotationProvider, ISeqSplitted, SeqSplittedBase, SplitterFunc}
   from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 import {getSplitterWithSeparator, StringListSeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
@@ -18,7 +22,22 @@ export class CyclizedNotationProvider implements INotationProvider {
   private _splitter(seq: string): ISeqSplitted {
     const baseSS: ISeqSplitted = this.separatorSplitter(seq);
     return new CyclizedSeqSplitted(baseSS.originals, GapOriginals[NOTATION.SEPARATOR]);
-  };
+  }
+
+  public async getHelm(seqCol: DG.Column<string>, options?: any): Promise<DG.Column<string>> {
+    const polyToolPackageName: string = 'SequenceTranslator';
+
+    const funcList = DG.Func.find({package: polyToolPackageName, name: 'polyToolConvert2'});
+    if (funcList.length == 0)
+      throw new Error(`Package '${polyToolPackageName}' must be installed for Cyclized notation provider.`);
+    const func = funcList[0];
+
+    const ptConvertCall = await func.prepare({table: seqCol.dataFrame, seqCol: seqCol, ...options});
+
+    const editorFunc = DG.Func.find({package: polyToolPackageName, name: 'getPolyToolConvertEditor'})[0];
+    const resHelmCol = (await editorFunc.prepare({call: ptConvertCall}).call()).getOutputParamValue() as DG.Column<string>;
+    return resHelmCol;
+  }
 }
 
 /** Gets canonical monomers for original ones with cyclization marks */

package/src/utils/dimerized.ts

@@ -0,0 +1,12 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {GAP_SYMBOL, INotationProvider, ISeqSplitted, SeqSplittedBase, SplitterFunc}
+  from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {CyclizedNotationProvider} from './cyclized';
+
+
+export class DimerizedNotationProvider extends CyclizedNotationProvider {
+
+}

package/src/utils/get-region-func-editor.ts

@@ -51,7 +51,7 @@ export class GetRegionFuncEditor {
 
     this.inputs.name = ui.input.string('Column name', {value: this.getDefaultName(),
       onValueChanged: this.nameInputChanged.bind(this), clearIcon: true});
-    this.inputs.name.onInput(this.nameInputInput.bind(this)); // To catch clear event
+    this.inputs.name.onInput.subscribe(() => this.nameInputInput.bind(this)); // To catch clear event
 
     // tooltips
     for (const paramName in this.call.inputParams) {

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

@@ -1,24 +1,30 @@
 /* Do not change these import lines to match external modules in webpack configuration */
 import * as DG from 'datagrok-api/dg';
-import * as grok from 'datagrok-api/grok';
 import * as OCL from 'openchemlib/full';
 
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {RDModule, RDMol} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
+import {IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {Polymer} from './polymer';
 import {GlobalMonomerPositionHandler} from './position-handler';
+import {MolfileWithMap, MonomerMap} from './types';
+
+import {_package} from '../../../package';
 
-import {_package, getMonomerLibHelper} from '../../../package';
 
 export class HelmToMolfileConverter {
-  constructor(private helmColumn: DG.Column<string>, private df: DG.DataFrame) {
-    this.helmColumn = helmColumn;
-  }
+  constructor(
+    private helmColumn: DG.Column<string>,
+    private df: DG.DataFrame,
+    private libHelper: IMonomerLibHelper,
+    private helmHelper: IHelmHelper,
+  ) { }
 
-  async convertToSmiles(): Promise<DG.Column<string>> {
-    const smiles = await this.getSmilesList();
+  convertToSmiles(rdKitModule: RDModule): DG.Column<string> {
+    const smiles = this.getSmilesList(rdKitModule);
     const columnName = this.df.columns.getUnusedName(`smiles(${this.helmColumn.name})`);
     return DG.Column.fromStrings(columnName, smiles.map((molecule) => {
       if (molecule === null)
@@ -27,13 +33,13 @@ export class HelmToMolfileConverter {
     }));
   }
 
-  private async getSmilesList(): Promise<string[]> {
-    const molfilesV2K = (await this.convertToMolfileV3KColumn()).toList();
+  private getSmilesList(rdKitModule: RDModule): string[] {
+    const molfilesV2K = this.convertToMolfileV3KColumn(rdKitModule).toList();
     const smiles = molfilesV2K.map((mol) => DG.chem.convert(mol, DG.chem.Notation.MolBlock, DG.chem.Notation.Smiles));
     return smiles;
   }
 
-  private async getMolV3000ViaOCL(beautifiedMols: (RDMol | null)[], columnName: string) {
+  public getMolV3000ViaOCL(beautifiedMols: (RDMol | null)[], columnName: string): DG.Column<string> {
     const beautifiedMolV2000 = beautifiedMols.map((mol) => {
       if (mol === null)
         return '';
@@ -54,9 +60,9 @@ export class HelmToMolfileConverter {
     return DG.Column.fromStrings(columnName, molv3000Arr);
   }
 
-  async convertToRdKitBeautifiedMolfileColumn(chiralityEngine?: boolean): Promise<DG.Column<string>> {
-    const molfilesV3K = (await this.convertToMolfileV3KColumn()).toList();
-    const rdKitModule: RDModule = await grok.functions.call('Chem:getRdKitModule');
+  // @deprecated Use SeqHelper.helmToAtomicLevel
+  convertToRdKitBeautifiedMolfileColumn(chiralityEngine: boolean, rdKitModule: RDModule): DG.Column<string> {
+    const molfilesV3K = this.convertToMolfileV3KColumn(rdKitModule).toList();
     const beautifiedMols = molfilesV3K.map((item) => {
       if (item === '')
         return null;
@@ -71,7 +77,7 @@ export class HelmToMolfileConverter {
     const columnName = this.df.columns.getUnusedName(`molfile(${this.helmColumn.name})`);
 
     if (chiralityEngine)
-      return await this.getMolV3000ViaOCL(beautifiedMols, columnName);
+      return this.getMolV3000ViaOCL(beautifiedMols, columnName);
     return DG.Column.fromStrings(columnName, beautifiedMols.map((mol) => {
       if (mol === null)
         return '';
@@ -81,34 +87,56 @@ export class HelmToMolfileConverter {
     }));
   }
 
-  private async convertToMolfileV3KColumn(): Promise<DG.Column<string>> {
-    const polymerGraphColumn: DG.Column<string> = await this.getPolymerGraphColumn();
-    const rdKitModule = await grok.functions.call('Chem:getRdKitModule');
-    const monomerLib: IMonomerLib = (await getMonomerLibHelper()).getMonomerLib();
+
+  public convertToMolfileV3KColumn(rdKitModule: RDModule): DG.Column<string> {
+    const polymerGraphColumn: DG.Column<string> = this.getPolymerGraphColumn();
+    const monomerLib: IMonomerLib = this.libHelper.getMonomerLib();
     const molfileList = polymerGraphColumn.toList().map(
       (pseudoMolfile: string, idx: number) => {
         const helm = this.helmColumn.get(idx);
-        if (!helm)
-          return '';
-        let result = '';
+        if (!helm) return '';
+
+        let resMolfileWithMap: MolfileWithMap;
         try {
-          result = this.getPolymerMolfile(helm, pseudoMolfile, rdKitModule, monomerLib);
+          resMolfileWithMap = this.getPolymerMolfile(helm, pseudoMolfile, rdKitModule, monomerLib);
         } catch (err: any) {
           const [errMsg, errStack] = errInfo(err);
           _package.logger.error(errMsg, undefined, errStack);
-        } finally {
-          return result;
+          resMolfileWithMap = MolfileWithMap.empty();
         }
+        return resMolfileWithMap.molfile;
       });
     const molfileColName = this.df.columns.getUnusedName(`molfileV2K(${this.helmColumn.name})`);
     const molfileColumn = DG.Column.fromList('string', molfileColName, molfileList);
     return molfileColumn;
   }
 
-  private async getPolymerGraphColumn(): Promise<DG.Column<string>> {
-    const polymerGraphColumn: DG.Column<string> =
-      await grok.functions.call('HELM:getMolfiles', {col: this.helmColumn});
-    return polymerGraphColumn;
+  public convertToMolfileV3K(rdKitModule: RDModule): MolfileWithMap[] {
+    const polymerGraphColumn: DG.Column<string> = this.getPolymerGraphColumn();
+    const monomerLib: IMonomerLib = this.libHelper.getMonomerLib();
+    const resList: MolfileWithMap[] = polymerGraphColumn.toList().map(
+      (pseudoMolfile: string, idx: number): MolfileWithMap => {
+        const helm = this.helmColumn.get(idx);
+        if (!helm) return {molfile: '', monomers: []};
+
+        let resMolfile: MolfileWithMap;
+        try {
+          resMolfile = this.getPolymerMolfile(helm, pseudoMolfile, rdKitModule, monomerLib);
+        } catch (err: any) {
+          const [errMsg, errStack] = errInfo(err);
+          _package.logger.error(errMsg, undefined, errStack);
+          resMolfile = MolfileWithMap.empty();
+        }
+        return resMolfile;
+      });
+    return resList;
+  }
+
+  private getPolymerGraphColumn(): DG.Column<string> {
+    const helmStrList = this.helmColumn.toList();
+    const molfileList = this.helmHelper.getMolfiles(helmStrList);
+    const molfileCol = DG.Column.fromStrings('mols', molfileList);
+    return molfileCol;
   }
 
   private getPolymerMolfile(
@@ -116,14 +144,14 @@ export class HelmToMolfileConverter {
     polymerGraph: string,
     rdKitModule: RDModule,
     monomerLib: IMonomerLib
-  ): string {
+  ): MolfileWithMap {
     const globalPositionHandler = new GlobalMonomerPositionHandler(polymerGraph);
     const polymer = new Polymer(helm, rdKitModule, monomerLib);
     globalPositionHandler.monomerSymbols.forEach((monomerSymbol: string, monomerIdx: number) => {
       const shift = globalPositionHandler.getMonomerShifts(monomerIdx);
       polymer.addMonomer(monomerSymbol, monomerIdx, shift);
     });
-    const polymerMolfile = polymer.compileToMolfile();
+    const polymerMolfile: MolfileWithMap = polymer.compileToMolfile();
     return polymerMolfile;
   }
 }

package/src/utils/helm-to-molfile/converter/mol-atoms.ts

@@ -4,6 +4,8 @@ export abstract class MolfileAtoms {
   protected coordinates: {x: number, y: number}[] = [];
   protected rawAtomLines: string[] = [];
 
+  get count(): number { return this.coordinates.length; }
+
   get atomCoordinates(): {x: number, y: number}[] {
     return this.coordinates;
   }

package/src/utils/helm-to-molfile/converter/mol-bonds.ts

@@ -4,6 +4,8 @@ export abstract class MolfileBonds {
   protected bondedAtomPairs: number[][] = [];
   protected rawBondLines: string[] = [];
 
+  public get count(): number { return this.bondedAtomPairs.length;}
+
   /** Get bond lines with new values for bonded atoms  */
   abstract getBondLines(): string[];
 

package/src/utils/helm-to-molfile/converter/mol-wrapper.ts

@@ -9,6 +9,10 @@ export abstract class MolfileWrapper {
   protected bonds: MolfileBonds;
   protected rGroups: RGroupHandler;
 
+  public get atomCount(): number { return this.atoms.count; }
+
+  public get bondCount(): number { return this.bonds.count; }
+
   protected shiftR1GroupToOrigin(): void {
     const r1Idx = this.rGroups.getAtomicIdx(1);
     if (r1Idx === null)
@@ -40,7 +44,7 @@ export abstract class MolfileWrapper {
     this.rGroups.deleteBondLineWithSpecifiedRGroup(rGroupId);
   }
 
-  shiftCoordinates(shift: {x: number, y: number}): void {
+  shiftCoordinates(shift: { x: number, y: number }): void {
     this.atoms.shift(shift);
   }
 

package/src/utils/helm-to-molfile/converter/monomer-wrapper.ts

@@ -8,12 +8,12 @@ import {MolfileWrapper} from './mol-wrapper';
 import {MolfileWrapperFactory} from './mol-wrapper-factory';
 
 export class MonomerWrapper {
-  private molfileWrapper: MolfileWrapper;
+  private readonly molfileWrapper: MolfileWrapper;
   private capGroupElements: string[] = [];
 
   constructor(
-    private monomerSymbol: string,
-    private monomerIdx: number,
+    public readonly monomerSymbol: string,
+    public readonly monomerIdx: number,
     private helm: Helm,
     shift: { x: number, y: number },
     rdKitModule: RDModule,
@@ -35,6 +35,10 @@ export class MonomerWrapper {
     this.shiftCoordinates(shift);
   }
 
+  public get atomCount() { return this.molfileWrapper.atomCount; }
+
+  public get bondCount() { return this.molfileWrapper.bondCount; }
+
   private convertMolfileToV3KFormat(molfileV2K: string, monomerSymbol: string, rdKitModule: RDModule): string {
     let mol: RDMol | null = null;
     try {

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

@@ -2,8 +2,11 @@ import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {V3K_CONST} from '@datagrok-libraries/chem-meta/src/formats/molfile-const';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
 
+import wu from 'wu';
+
 import {Helm} from './helm';
 import {MonomerWrapper} from './monomer-wrapper';
+import {MolfileWithMap, MonomerMap} from './types';
 
 export class Polymer {
   constructor(
@@ -50,7 +53,7 @@ export class Polymer {
     });
   }
 
-  compileToMolfile(): string {
+  compileToMolfile(): MolfileWithMap {
     const atomLines: string[] = [];
     const bondLines: string[] = [];
 
@@ -61,10 +64,22 @@ export class Polymer {
 
     this.restoreBondsBetweenMonomers();
 
-    this.monomerWrappers.forEach((monomerWrapper) => {
-      atomLines.push(...monomerWrapper.getAtomLines());
-      bondLines.push(...monomerWrapper.getBondLines());
-    });
+    const monomers: MonomerMap[] = new Array<MonomerMap>(this.monomerWrappers.length);
+    for (const [mw, mwI] of wu.enumerate(this.monomerWrappers)) {
+      const mwAtomFirst = atomLines.length;
+      const mwBondFirst = bondLines.length;
+
+      atomLines.push(...mw.getAtomLines());
+      bondLines.push(...mw.getBondLines());
+
+      monomers[mwI] = {
+        position: mwI,
+        // TODO: PolymerType
+        symbol: mw.monomerSymbol,
+        atoms: wu.count(mwAtomFirst).take(mw.atomCount).toArray(),
+        bonds: wu.count(mwBondFirst).take(mw.bondCount).toArray(),
+      };
+    }
 
     const atomCount = atomLines.length;
     const bondCount = bondLines.length;
@@ -75,7 +90,7 @@ export class Polymer {
     const molfileEnd = V3K_CONST.END_CTAB + '\n' + V3K_CONST.END;
     const blockList = [header, atomBlock, bondBlock, molfileEnd];
     const molfile = blockList.join('\n');
-    return molfile;
+    return {molfile, monomers};
   }
 
   private getV3KHeader(atomCount: number, bondCount: number): string {

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

@@ -10,3 +10,14 @@ export type PositionInBonds = {
   bondLineIdx: number,
   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

@@ -1,23 +1,18 @@
-/* Do not change these import lines to match external modules in webpack configuration */
-import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
 
-import {HelmToMolfileConverter} from './converter';
-
-/** Translate HELM column into molfile column and append to the dataframe */
-export async function helm2mol(df: DG.DataFrame, helmCol: DG.Column<string>): Promise<void> {
-  const molCol = await getMolColumnFromHelm(df, helmCol);
-  df.columns.add(molCol, true);
-  await grok.data.detectSemanticTypes(df);
-}
+import {_package} from '../../package';
+import {SeqHelper} from '../seq-helper';
 
 
 /** Translate HELM column into molfile column and append to the dataframe */
 export async function getMolColumnFromHelm(
-  df: DG.DataFrame, helmCol: DG.Column<string>, chiralityEngine?: boolean
+  df: DG.DataFrame, helmCol: DG.Column<string>, chiralityEngine: boolean = true
 ): Promise<DG.Column<string>> {
-  const converter = new HelmToMolfileConverter(helmCol, df);
-  const molCol = await converter.convertToRdKitBeautifiedMolfileColumn(chiralityEngine);
+  const seqHelper = await SeqHelper.getInstance();
+  const converter = seqHelper.getHelmToMolfileConverter(df, helmCol);
+  const molCol = converter.convertToRdKitBeautifiedMolfileColumn(chiralityEngine, _package.rdKitModule);
   molCol.semType = DG.SEMTYPE.MOLECULE;
   return molCol;
 }
@@ -25,8 +20,9 @@ export async function getMolColumnFromHelm(
 export async function getSmilesColumnFromHelm(
   df: DG.DataFrame, helmCol: DG.Column<string>
 ): Promise<DG.Column<string>> {
-  const converter = new HelmToMolfileConverter(helmCol, df);
-  const smilesCol = await converter.convertToSmiles();
+  const seqHelper = await SeqHelper.getInstance();
+  const converter = seqHelper.getHelmToMolfileConverter(df, helmCol);
+  const smilesCol = converter.convertToSmiles(_package.rdKitModule);
   smilesCol.semType = DG.SEMTYPE.MOLECULE;
   return smilesCol;
 }

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

@@ -83,6 +83,20 @@ export class MonomerLibManager implements IMonomerLibHelper {
     return this._monomerSets;
   }
 
+  /** Object containing symbols for each type of polymer where duplicate monomers are found in different libs (based on symbol as key) */
+  get duplicateMonomers() {
+    return this._monomerLib.duplicateMonomers;
+  }
+
+  /** Returns true if all duplicate monomers are assigned preferences (which library they are coming from) */
+  get duplicatesHandled() {
+    return this._monomerLib.duplicatesHandled;
+  }
+
+  assignDuplicatePreferances(settings: UserLibSettings) {
+    this._monomerLib.assignDuplicatePreferances(settings);
+  }
+
   /** Instance promise of {@link getFileManager} */
   private _fileManagerPromise?: Promise<MonomerLibFileManager>;
 
@@ -256,7 +270,7 @@ export class MonomerLibManager implements IMonomerLibHelper {
   // -- Instance singleton --
   public static async getInstance(): Promise<MonomerLibManager> {
     let res = window.$monomerLibHelperPromise;
-    if (res === undefined) {
+    if (res == undefined) {
       res = window.$monomerLibHelperPromise = (async () => {
         const instance = new MonomerLibManager(_package.logger);
         instance._eventManager = MonomerLibFileEventManager.getInstance();