@datagrok/sequence-translator 1.4.4 → 1.4.5

package/files/polytool-rules/rules_example.json

@@ -25,7 +25,7 @@
   },
   {
     "type": "reaction",
-    "code": "3",
+    "code": "4",
     "monomericSubstitution": {
       "firstMonomer": "azG",
       "secondMonomer": "aG",

package/files/samples/cyclized.csv

@@ -1,8 +1,8 @@
 n,seqs
 1,R-F-C(1)-T-G-H-F-Y-G-H-F-Y-G-H-F-Y-P-C(1)-meI
-2,C(1)-T-G-H-F-Y-P-C(1)-meI
+2,C(1)-T-G-Aca-F-Y-P-C(1)-meI
 3,R-F-C(1)-T-G-H-F-Y-P-C(1)
 4,C(1)-T-G-H-F-H-P-C(1)
 5,R-F-D(2)-T-G-H-F-Y-P-NH2(2)
-6,R-F-azG(3)-T-G-H-F-Y-P-aG(3)-meI
-7,R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI
+6,R-F-azG(4)-T-G-H-F-Y-P-aG(4)-meI
+7,R-F-aG(4)-T-G-H-F-Y-P-azG(4)-meI

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "author": {
     "name": "Alexey Chopovsky",
     "email": "achopovsky@datagrok.ai"
@@ -22,10 +22,10 @@
     }
   ],
   "dependencies": {
-    "@datagrok-libraries/bio": "^5.44.2",
+    "@datagrok-libraries/bio": "^5.45.2",
     "@datagrok-libraries/chem-meta": "^1.2.7",
-    "@datagrok-libraries/tutorials": "^1.4.0",
-    "@datagrok-libraries/utils": "^4.3.5",
+    "@datagrok-libraries/tutorials": "^1.4.3",
+    "@datagrok-libraries/utils": "^4.3.6",
     "@types/react": "^18.0.15",
     "cash-dom": "^8.1.0",
     "datagrok-api": "^1.21.1",
@@ -36,32 +36,32 @@
     "ts-loader": "^9.3.1",
     "typeahead-standalone": "4.14.1",
     "typescript": "^5.4.2",
-    "wu": "latest"
+    "wu": "^2.1.0"
   },
   "devDependencies": {
-    "@datagrok-libraries/helm-web-editor": "^1.1.11",
-    "@datagrok-libraries/js-draw-lite": "^0.0.8",
-    "@datagrok/bio": "^2.15.6",
-    "@datagrok/helm": "^2.5.3",
-    "@datagrok/chem": "^1.12.1",
+    "@datagrok-libraries/helm-web-editor": "^1.1.12",
+    "@datagrok-libraries/js-draw-lite": "^0.0.9",
+    "@datagrok/bio": "^2.16.2",
+    "@datagrok/helm": "^2.5.4",
+    "@datagrok/chem": "^1.12.3",
     "@types/jquery": "^3.5.14",
     "@types/js-yaml": "^4.0.5",
     "@types/lodash": "^4.14.202",
     "@types/node-fetch": "^2.6.2",
     "@types/object-hash": "^3.0.6",
     "@types/react": "^18.0.15",
-    "@types/wu": "latest",
+    "@types/wu": "^2.1.44",
     "@typescript-eslint/eslint-plugin": "^7.2.0",
     "@typescript-eslint/parser": "^7.2.0",
     "css-loader": "^6.7.3",
     "eslint": "^8.57.0",
-    "eslint-config-google": "latest",
+    "eslint-config-google": "^0.14.0",
     "style-loader": "^3.3.1",
     "ts-loader": "^9.3.1",
     "typescript": "^4.7.4",
     "typescript-eslint": "^7.2.0",
     "webpack": "^5.75.0",
-    "webpack-cli": "latest"
+    "webpack-cli": "^5.1.4"
   },
   "scripts": {
     "link-api": "npm link datagrok-api",

package/src/apps/common/model/oligo-toolkit-package.ts

@@ -16,8 +16,16 @@ import {MonomerLibWrapper} from './monomer-lib/lib-wrapper';
 import {FormatConverter} from '../../translator/model/format-converter';
 import {FormatDetector} from './parsing-validation/format-detector';
 import {highlightInvalidSubsequence} from '../view/components/colored-input/input-painters';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 export class OligoToolkitPackage extends DG.Package implements ITranslationHelper {
+  private _seqHelper: ISeqHelper;
+  public get seqHelper(): ISeqHelper {
+    if (!this._seqHelper)
+      throw new Error('Package SequenceTranslator .seqHelper is not initialized');
+    return this._seqHelper;
+  }
+
   private _monomerLib?: IMonomerLib;
   get monomerLib(): IMonomerLib {
     if (!this._monomerLib)
@@ -47,6 +55,10 @@ export class OligoToolkitPackage extends DG.Package implements ITranslationHelpe
 
   private initPromise?: Promise<void>;
 
+  completeInit(seqHelper: ISeqHelper): void {
+    this._seqHelper = seqHelper;
+  }
+
   async initLibData(): Promise<void> {
     if (!this.initPromise) {
       this.initPromise = (async () => {

package/src/apps/common/view/components/molecule-img.ts

@@ -17,8 +17,8 @@ export class MoleculeImage {
     this.molblock = molblok;
   }
 
-  private _validMolBlock: string;
-  get molblock(): string { return this._validMolBlock; }
+  private _validMolBlock!: string;
+  get molblock(): string { return this._validMolBlock!; }
 
   set molblock(value: string) {
     if (value === '') {

package/src/apps/pattern/model/data-manager.ts

@@ -33,7 +33,7 @@ export class DataManager {
     instance.currentUserName = await instance.fetchCurrentUserName();
     instance.currentUserId = await instance.fetchCurrentUserId();
 
-    const patternRecords = await instance.fetchPatterns();
+    const patternRecords = instance.fetchPatterns();
     await instance.initializePatternMaps(patternRecords);
 
     return instance;
@@ -81,7 +81,7 @@ export class DataManager {
     if (hash === null || hash === '')
       return null;
     try {
-      const patternConfig = await grok.dapi.userDataStorage.getValue(STORAGE_NAME, hash, false);
+      const patternConfig = grok.userSettings.getValue(STORAGE_NAME, hash, false) ?? 'null';
       const config = JSON.parse(patternConfig) as PatternConfigRecord;
       return config;
     } catch {
@@ -181,7 +181,7 @@ export class DataManager {
         [D.MODIFY]: timestamp,
       };
       const record = JSON.stringify(recordObj);
-      await grok.dapi.userDataStorage.postValue(STORAGE_NAME, hash, record, false);
+      grok.userSettings.add(STORAGE_NAME, hash, record, false);
       this.currentUserPatternNameToHash.set(patternName, hash);
 
       eventBus.selectAuthor(this.getCurrentUserAuthorshipCategory());
@@ -212,14 +212,14 @@ export class DataManager {
     newRecordObj[R.DATE] = {
       [D.MODIFY]: timestamp,
     };
-    const oldPattern = await grok.dapi.userDataStorage.getValue(STORAGE_NAME, oldHash, false);
+    const oldPattern = grok.userSettings.getValue(STORAGE_NAME, oldHash, false) ?? 'null';
     const oldPatternsRecord = JSON.parse(oldPattern) as PatternConfigRecord;
     if (oldPatternsRecord[R.DATE] !== undefined && oldPatternsRecord[R.DATE][D.CREATE] != undefined)
       newRecordObj[R.DATE][D.CREATE] = oldPatternsRecord[R.DATE][D.CREATE];
 
     const newRecord = JSON.stringify(newRecordObj);
-    await grok.dapi.userDataStorage.postValue(STORAGE_NAME, newHash, newRecord, false);
-    await grok.dapi.userDataStorage.remove(STORAGE_NAME, oldHash, false);
+    grok.userSettings.add(STORAGE_NAME, newHash, newRecord, false);
+    grok.userSettings.delete(STORAGE_NAME, oldHash, false);
 
     this.currentUserPatternNameToHash.set(patternName, newHash);
     eventBus.requestPatternLoad(newHash);
@@ -237,7 +237,7 @@ export class DataManager {
     }
     if (hash === undefined)
       throw new Error(`Pattern with name ${patternName} not found`);
-    await grok.dapi.userDataStorage.remove(STORAGE_NAME, hash, false);
+    grok.userSettings.delete(STORAGE_NAME, hash, false);
     this.currentUserPatternNameToHash.delete(patternName);
     eventBus.updatePatternList();
 
@@ -264,8 +264,8 @@ export class DataManager {
     return (await grok.dapi.users.current()).id;
   }
 
-  private async fetchPatterns() {
-    const patternsRecord = await grok.dapi.userDataStorage.get(STORAGE_NAME, false) as RawPatternRecords;
+  private fetchPatterns(): RawPatternRecords {
+    const patternsRecord = (grok.userSettings.get(STORAGE_NAME, false) ?? {}) as RawPatternRecords;
     return patternsRecord;
   }
 

package/src/apps/translator/view/ui.ts

@@ -3,9 +3,10 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 
+import $ from 'cash-dom';
 import {Subject, BehaviorSubject, Observable} from 'rxjs';
 
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 import {DEFAULT_FORMATS} from '../../common/model/const';
@@ -22,7 +23,6 @@ import {ITranslationHelper} from '../../../types';
 
 import {NUCLEOTIDES_FORMAT, SEQUENCE_COPIED_MSG, SEQ_TOOLTIP_MSG} from './const';
 import './style.css';
-import $ from 'cash-dom';
 import {_package} from '../../../package';
 
 const enum REQUIRED_COLUMN_LABEL {
@@ -34,9 +34,10 @@ const REQUIRED_COLUMN_LABELS = [REQUIRED_COLUMN_LABEL.SEQUENCE];
 class TranslatorAppLayout {
   private eventBus: EventBus;
   private inputFormats = Object.keys(_package.jsonData.codesToHelmDict).concat(DEFAULT_FORMATS.HELM);
+  private readonly seqHelper: ISeqHelper = _package.seqHelper;
 
   constructor(
-    private readonly th: ITranslationHelper
+    private readonly th: ITranslationHelper,
   ) {
     this.moleculeImgDiv = ui.div([]);
     this.moleculeImgDiv.className = 'mol-host';
@@ -171,9 +172,9 @@ class TranslatorAppLayout {
       translatedColumn.semType = DG.SEMTYPE.MACROMOLECULE;
       const units = outputFormat == NUCLEOTIDES_FORMAT ? NOTATION.FASTA : NOTATION.HELM;
       translatedColumn.meta.units = units;
-      const seqHandler = SeqHandler.forColumn(translatedColumn as DG.Column<string>);
-      const setUnits = outputFormat == NUCLEOTIDES_FORMAT ? SeqHandler.setUnitsToFastaColumn :
-        SeqHandler.setUnitsToHelmColumn;
+      const seqHandler = this.seqHelper.getSeqHandler(translatedColumn as DG.Column<string>);
+      const setUnits = outputFormat == NUCLEOTIDES_FORMAT ? this.seqHelper.setUnitsToFastaColumn :
+        this.seqHelper.setUnitsToHelmColumn;
       setUnits(seqHandler);
     }
 
@@ -462,8 +463,7 @@ class ColumnInputsManager {
     const input = ui.input.choice(`${columnLabel}`, {
       value: selectedColumnName, items: columnNames,
       onValueChanged: (value) => this.selectColumnIfTableNotNull(selectedTable, value, columnLabel)
-    }
-    );
+    });
 
     return input;
   }

package/src/package-test.ts

@@ -8,10 +8,12 @@ import './tests/formats-to-helm';
 import './tests/helm-to-nucleotides';
 import './tests/formats-support';
 import './tests/files-tests';
+import './tests/polytool-detectors-custom-notation-test';
 import './tests/polytool-convert-tests';
 import './tests/polytool-unrule-tests';
 import './tests/polytool-enumerate-tests';
 import './tests/polytool-enumerate-breadth-tests';
+import './tests/polytool-chain-parse-notation-tests';
 import './tests/toAtomicLevel-tests';
 
 import {OligoToolkitTestPackage} from './tests/utils';

package/src/package.ts

@@ -2,16 +2,15 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {MonomerLibWrapper} from './apps/common/model/monomer-lib/lib-wrapper';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {SeqTemps} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
+
 import {OligoToolkitPackage} from './apps/common/model/oligo-toolkit-package';
-import {FormatDetector} from './apps/common/model/parsing-validation/format-detector';
-import {SequenceValidator} from './apps/common/model/parsing-validation/sequence-validator';
 import {APP_NAME} from './apps/common/view/const';
 import {getSpecifiedAppUI} from './apps/common/view/utils';
 import {CombinedAppUI} from './apps/common/view/combined-app-ui';
 import {linkStrandsV3000} from './apps/structure/model/mol-transformations';
 import {SequenceToMolfileConverter} from './apps/structure/model/sequence-to-molfile';
-import {FormatConverter} from './apps/translator/model/format-converter';
 import {demoOligoPatternUI, demoOligoStructureUI, demoOligoTranslatorUI} from './demo/demo-st-ui';
 import {getExternalAppViewFactories} from './plugins/mermade';
 import {defaultErrorHandler} from './utils/err-info';
@@ -26,9 +25,27 @@ import {ITranslationHelper} from './types';
 import {addContextMenuUI} from './utils/context-menu';
 import {PolyToolConvertFuncEditor} from './polytool/pt-convert-editor';
 import {polyToolUnruleUI} from './polytool/pt-unrule';
+import {CyclizedNotationProvider} from './utils/cyclized';
+import {getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 export const _package: OligoToolkitPackage = new OligoToolkitPackage({debug: true}/**/);
 
+let initSequenceTranslatorPromise: Promise<void> | null = null;
+
+//tags: init
+export async function init(): Promise<void> {
+  if (initSequenceTranslatorPromise === null)
+    initSequenceTranslatorPromise = initSequenceTranslatorInt();
+  return initSequenceTranslatorPromise;
+}
+
+async function initSequenceTranslatorInt(): Promise<void> {
+  const [seqHelper] = await Promise.all([
+    getSeqHelper(),
+  ]);
+  _package.completeInit(seqHelper);
+}
+
 //name: Oligo Toolkit
 //meta.icon: img/icons/toolkit.png
 //meta.browsePath: Oligo
@@ -277,3 +294,12 @@ export async function ptEnumeratorHelmApp(): Promise<void> {
 export async function ptEnumeratorChemApp(): Promise<void> {
   polyToolEnumerateChemUI();
 }
+
+//name: applyNotationProviderForHarmonizedSequence
+//input: column col
+//input: string separator
+export function applyNotationProviderForCyclized(col: DG.Column<string>, separator: string) {
+  col.meta.units = NOTATION.CUSTOM;
+  col.tags['pt-role'] = 'template';
+  col.temp[SeqTemps.notationProvider] = new CyclizedNotationProvider(separator, _package.seqHelper);
+}

package/src/polytool/pt-conversion.ts

@@ -2,36 +2,39 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
-import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import wu from 'wu';
+
+import {HelmTypes, PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {IMonomerLib, IMonomerLibBase, Monomer, MonomerLibData, RGroup} from '@datagrok-libraries/bio/src/types';
 import {RDModule, RDMol, RDReaction, MolList, RDReactionResult} from '@datagrok-libraries/chem-meta/src/rdkit-api';
-import {HELM_REQUIRED_FIELD, HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
+import {HELM_REQUIRED_FIELD as REQ, HELM_OPTIONAL_FIELDS as OPT, HELM_RGROUP_FIELDS, HELM_OPTIONAL_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
 import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+import {HelmMol, HelmType, JSDraw2ModuleType, OrgType} from '@datagrok-libraries/bio/src/helm/types';
+import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {Rules, RuleLink, RuleReaction} from './pt-rules';
 import {InvalidReactionError, MonomerNotFoundError} from './types';
-import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+
 import {_package} from '../package';
 
-export const RULES_DIMER = '(#2)';
-export const RULES_HETERODIMER = '($2)';
+declare const JSDraw2: JSDraw2ModuleType;
+declare const org: OrgType;
 
-// function addCommonTags(col: DG.Column): void {
-//   col.semType = DG.SEMTYPE.MACROMOLECULE;
-//   col.setTag('aligned', ALIGNMENT.SEQ);
-//   col.setTag('alphabet', ALPHABET.PT);
-// }
 
 export class Chain {
   linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[];
   monomers: string[][];
+  mol: HelmMol | null;
 
   constructor(
     monomers: string[][],
-    linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[]) {
+    linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[],
+    mol: HelmMol | null) {
     this.linkages = linkages;
     this.monomers = monomers;
+    this.mol = mol;
   }
 
   static fromHelm(helm: string) {
@@ -78,7 +81,7 @@ export class Chain {
       }
     }
 
-    return new Chain(monomers, linkages);
+    return new Chain(monomers, linkages, null);
   }
 
   static fromNotation(sequence: string, rules: Rules): Chain {
@@ -223,7 +226,97 @@ export class Chain {
       }
     }
 
-    const chain = new Chain(monomersAll, linkages);
+    const chain = new Chain(monomersAll, linkages, null);
+    return chain;
+  }
+
+  static async parseNotation(sequence: string): Promise<Chain> {
+    const mainFragments: string[][] = [];
+
+    const linkages: {
+      fChain: number,
+      sChain: number,
+      fMonomer: number,
+      sMonomer: number,
+      fR: number,
+      sR: number
+    }[] = [];
+
+
+    const hh = await getHelmHelper();
+    // const sampleHwe = hh.createHelmWebEditor();
+    // sampleHwe.editor.setHelm('PEPTIDE1{R.P.D.[meI]}$$$$');
+
+    const resHwe = hh.createHelmWebEditor();
+    const resMol = resHwe.editor.m;
+
+    const rxp = /(\(.\d+\))?\{[^\}]*\}/g;
+    const seqs: string [] = [];
+    seqs.push(sequence.replaceAll(rxp, ''));
+
+    //const l = (rxpRes?.length) ?? -1;
+
+    const matches = sequence.matchAll(rxp);
+    //const rxpRes = rxp.exec(sequence);
+    for (const m of matches) {
+      const str = m![0];
+      if (str)
+        seqs.push(str);
+    }
+
+    let counter = 0;
+    for (let i = 0; i < seqs.length; i++) {
+      const splMonomers = seqs[i].split('-');
+      const monomers: string [] = new Array<string>(splMonomers.length);
+      for (let j = 0; j < splMonomers.length; j++) {
+        const monomer = splMonomers[j].replace('{', '').replace('}', '');
+        if (monomer !== '') {
+          monomers[j] = monomer;
+          counter++;
+        } else {
+          linkages.push({fChain: i, sChain: i + 1, fMonomer: counter, sMonomer: counter + 1, fR: 1, sR: 1});
+        }
+      }
+
+      mainFragments.push(monomers);
+    }
+
+    counter = 0;
+    const p = new JSDraw2.Point(0, 0);
+    for (let i = 0; i < mainFragments.length; i++) {
+      for (let j = 0; j < mainFragments[i].length; j++) {
+        if (!!mainFragments[i][j]) {
+          const elem = mainFragments[i][j];
+          const bio = {type: HelmTypes.AA, i: i, j: j};
+          const atom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          resMol.addAtom(atom);
+
+          if (j !== 0) {
+            const atom1 = resMol.atoms[counter - 1];
+            const atom2 = resMol.atoms[counter];
+            const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+            bond.r1 = 2;
+            bond.r2 = 1;
+            resMol.addBond(bond);
+          }
+
+          counter++;
+          p.x += JSDraw2.Editor.BONDLENGTH; // Inspired by HELMWebEditor
+        }
+        p.y += 4 * JSDraw2.Editor.BONDLENGTH; // Inspired by HELMWebEditor
+      }
+    }
+
+    for (let i = 0; i < linkages.length; i++) {
+      const atom1 = resMol.atoms[linkages[i].fMonomer - 1];
+      const atom2 = resMol.atoms[linkages[i].sMonomer - 1];
+      const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+      bond.r1 = linkages[i].fR;
+      bond.r2 = linkages[i].sR;
+      resMol.addBond(bond);
+    }
+
+    const chain = new Chain(mainFragments, linkages, resMol);
     return chain;
   }
 
@@ -233,17 +326,17 @@ export class Chain {
     let idx1 = 0;
     let idx2 = 0;
     loop1:
-      for (let i = 0; i < this.monomers.length; i++) {
-        loop2:
-          for (let j = 0; j < this.monomers[i].length; j++) {
-            if (counter == changeNumber) {
-              idx1 = i;
-              idx2 = j;
-              break loop1;
-            }
-            counter++;
-          }
+    for (let i = 0; i < this.monomers.length; i++) {
+      loop2:
+      for (let j = 0; j < this.monomers[i].length; j++) {
+        if (counter == changeNumber) {
+          idx1 = i;
+          idx2 = j;
+          break loop1;
+        }
+        counter++;
       }
+    }
 
     const previous = this.monomers[idx1][idx2];
 
@@ -254,6 +347,10 @@ export class Chain {
     return res;
   }
 
+  getNotationHelm(): string {
+    return this.getHelm();
+  }
+
   getHelm(): string {
     let helm = '';
     for (let i = 0; i < this.monomers.length; i++) {
@@ -285,8 +382,66 @@ export class Chain {
     return helm;
   }
 
-  getNotation(rules: Rules): string {
-    return 'not implemented';
+  getNotation(): string {
+    const atoms = this.mol!.atoms;
+    const bonds = this.mol!.bonds;
+    const chains: number[] = [];
+    const specialBonds: number[] = [];
+    for (let i = 0; i < bonds.length!; i++) {
+      //@ts-ignore
+      if (bonds[i].a1.bio.i !== bonds[i].a2.bio.i)
+        specialBonds.push(i);
+    }
+
+    for (let i = 0; i < atoms.length!; i++) {
+      //@ts-ignore
+      const atomChain = atoms[i].bio?.i;
+      if (atomChain + 1 > chains.length)
+        chains.push(1);
+      else
+        chains[atomChain]++;
+    }
+
+    const simpleChains: string[][] = new Array(chains.length);
+    let counter = 0;
+    for (let i = 0; i < chains.length!; i++) {
+      const simpleChain: string[] = new Array(chains[i]);
+      for (let j = 0; j < chains[i]; j++) {
+        simpleChain[j] = atoms[counter].elem;
+        counter++;
+      }
+
+      simpleChains[i] = simpleChain;
+    }
+
+    let res = '';
+    for (let i = 0; i < simpleChains.length; i++) {
+      let chainAdd = '';
+
+      for (let j = 0; j < simpleChains[i].length; j++)
+        chainAdd += `${j == 0 ? '' : '-'}${simpleChains[i][j]}`;
+
+      if (i !== 0) {
+        const rxp = /(\(.\d+\))/;
+        const match = chainAdd.match(rxp);
+        chainAdd = chainAdd.replace(match?.[0]!, '');
+        const group = match ? match?.[0]! : '';
+        chainAdd = `${group}{${chainAdd}}`;
+      } else {
+        if (simpleChains.length > 1) {
+          //@ts-ignore
+          const firstAtomLinks = bonds[specialBonds[0]].a1.bio.i == 0 && bonds[specialBonds[0]].a1.bio.j == 0;
+          //@ts-ignore
+          const secondAtomLinks = bonds[specialBonds[0]].a2.bio.i == 1 && bonds[specialBonds[0]].a1.bio.j == 0;
+          if (firstAtomLinks && secondAtomLinks)
+            chainAdd += '-';
+        }
+      }
+
+      res += chainAdd;
+    }
+
+    return res;
   }
 
   protected static getLinkedPositions(monomers: string[], rules: RuleLink[] | RuleReaction []):
@@ -517,18 +672,24 @@ export function getNewMonomer(rdkit: RDModule, mLib: IMonomerLib, rule: RuleReac
   const groups: RGroup[] = getNewGroups(monomer1!, monomer2!);
 
   const resMonomer: Monomer = {
-    [HELM_REQUIRED_FIELD.SYMBOL]: monomerName,
-    [HELM_REQUIRED_FIELD.NAME]: monomerName,
-    [HELM_REQUIRED_FIELD.MOLFILE]: molBlock,
-    [HELM_REQUIRED_FIELD.AUTHOR]: '',
-    [HELM_REQUIRED_FIELD.ID]: 0,
-    [HELM_REQUIRED_FIELD.RGROUPS]: groups,
-    [HELM_REQUIRED_FIELD.SMILES]: '',
-    [HELM_REQUIRED_FIELD.POLYMER_TYPE]: 'PEPTIDE',
-    [HELM_REQUIRED_FIELD.MONOMER_TYPE]: 'Backbone',
-    [HELM_REQUIRED_FIELD.CREATE_DATE]: null,
+    [REQ.SYMBOL]: monomerName,
+    [REQ.NAME]: monomerName,
+    [REQ.MOLFILE]: molBlock,
+    [REQ.AUTHOR]: '',
+    [REQ.ID]: 0,
+    [REQ.RGROUPS]: groups,
+    [REQ.SMILES]: '',
+    [REQ.POLYMER_TYPE]: 'PEPTIDE',
+    [REQ.MONOMER_TYPE]: 'Backbone',
+    [REQ.CREATE_DATE]: null,
+
+    // // @ts-ignore
+    // lib: {source: 'Reaction'},
   };
 
+  resMonomer[OPT.META] = Object.assign(resMonomer[OPT.META] ?? {},
+    {'colors': {'default': {line: '#2083D5', text: '#2083D5', background: '#F2F2F5'}}});
+
   return [monomerName, resMonomer];
 }
 
@@ -545,6 +706,7 @@ export async function getOverriddenLibrary(rules: Rules): Promise<IMonomerLibBas
   }
 
   const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: argLib};
-  const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData);
+  const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData,
+    'ST-PT-reactions.' + wu.repeat(1).map(() => Math.floor((Math.random() * 36)).toString(36)).take(4).toArray().join(''));
   return overriddenMonomerLib;
 }

package/src/polytool/pt-dialog.ts

@@ -9,7 +9,10 @@ import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {MmcrTemps} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
+import {buildMonomerHoverLink} from '@datagrok-libraries/bio/src/monomer-works/monomer-hover';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
 import {getRules, RuleInputs, Rules, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
 import {doPolyToolConvert, getOverriddenLibrary} from './pt-conversion';
@@ -74,7 +77,7 @@ export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.D
       table: srcColVal.dataFrame, value: srcColVal,
       filter: (col: DG.Column) => {
         if (col.semType !== DG.SEMTYPE.MACROMOLECULE) return false;
-        const sh = SeqHandler.forColumn(col);
+        const sh = _package.seqHelper.getSeqHandler(col);
         return sh.notation === NOTATION.CUSTOM;
       }
     });
@@ -256,7 +259,11 @@ export async function polyToolConvert(
     if (generateHelm && table) table.columns.add(resHelmCol, true);
 
     const seqHelper: ISeqHelper = await getSeqHelper();
+    const rdKitModule: RDModule = await getRdKitModule();
     const lib = await getOverriddenLibrary(rules);
+    const resHelmColTemp = resHelmCol.temp;
+    resHelmColTemp[MmcrTemps.overriddenLibrary] = lib;
+    resHelmCol.temp = resHelmColTemp;
     const toAtomicLevelRes =
       await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, /* highlight */ generateHelm, lib);
     const resMolCol = toAtomicLevelRes.molCol!;
@@ -267,6 +274,9 @@ export async function polyToolConvert(
       table.columns.add(resMolCol, true);
       await grok.data.detectSemanticTypes(table);
     }
+
+    buildMonomerHoverLink(resHelmCol, resMolCol, lib, seqHelper, rdKitModule);
+
     return [resHelmCol, resMolCol];
   } finally {
     pi.close();