@datagrok/sequence-translator 1.4.3 → 1.4.5

package/src/polytool/pt-conversion.ts

@@ -1,29 +1,40 @@
-// import * as grok from 'datagrok-api/grok';
-// import * as DG from 'datagrok-api/dg';
-
-
-//import {ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
+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 {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 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 {_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) {
@@ -32,7 +43,14 @@ export class Chain {
     const rawLinkages = fragmentation[1].split('|');
 
     const monomers = new Array<Array<string>>(rawFragments.length);
-    const linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[] = [];
+    const linkages: {
+      fChain: number,
+      sChain: number,
+      fMonomer: number,
+      sMonomer: number,
+      fR: number,
+      sR: number
+    }[] = [];
 
     //HELM parsing
     for (let i = 0; i < rawFragments.length; i++) {
@@ -63,7 +81,7 @@ export class Chain {
       }
     }
 
-    return new Chain(monomers, linkages);
+    return new Chain(monomers, linkages, null);
   }
 
   static fromNotation(sequence: string, rules: Rules): Chain {
@@ -71,7 +89,14 @@ export class Chain {
     const homodimerCode = rules.homodimerCode;
     const mainFragments: string[] = [];
 
-    const linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[] = [];
+    const linkages: {
+      fChain: number,
+      sChain: number,
+      fMonomer: number,
+      sMonomer: number,
+      fR: number,
+      sR: number
+    }[] = [];
 
     //NOTICE: this works only with simple single heterodimers
     const heterodimeric = heterodimerCode !== null ? sequence.split(`(${rules.heterodimerCode!})`) : '';
@@ -201,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;
   }
 
@@ -211,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];
 
@@ -232,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++) {
@@ -263,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 []):
@@ -374,10 +551,162 @@ export class Chain {
 export function doPolyToolConvert(sequences: string[], rules: Rules): string[] {
   const helms = new Array<string>(sequences.length);
   for (let i = 0; i < sequences.length; i++) {
-    if (sequences[i] == null) { helms[i] = ''; } else {
-      const chain = Chain.fromNotation(sequences[i], rules);
-      helms[i] = chain.getHelm();
+    try {
+      if (sequences[i] == null) { helms[i] = ''; } else {
+        const chain = Chain.fromNotation(sequences[i], rules);
+        helms[i] = chain.getHelm();
+      }
+    } catch (err: any) {
+      const [errMsg, errStack] = errInfo(err);
+      _package.logger.error(errMsg, undefined, errStack);
+      helms[i] = '';
     }
   }
   return helms;
 }
+
+function getMonomersMolBlocks(monomer1: Monomer, monomer2: Monomer): [string, string] {
+  const mb1 = monomer1.molfile;
+  let mb2 = monomer2.molfile;
+  const addGroups = monomer1.rgroups.length;
+
+  //mol v2000 monomer
+  const rgpIdx = mb2.indexOf('M  RGP');
+  if (rgpIdx !== -1) {
+    const groupsCountStr = mb2.substring(rgpIdx + 6, rgpIdx + 9);
+    const groupsCount = Number(groupsCountStr);
+
+    for (let i = 0; i < groupsCount; i++) {
+      const start = rgpIdx + 9 + 4 + i * 8;
+      const end = rgpIdx + 9 + 8 + i * 8;
+      const rGroupSpecifier = mb2.substring(start, end);
+      const groupPosition = Number(rGroupSpecifier) + addGroups;
+      const digits = Math.floor(Math.log10(groupPosition) + 1);
+      const newSpecifier = ' '.repeat(4 - digits) + String(groupPosition);
+      mb2 = mb2.substring(0, start) + newSpecifier + mb2.substring(end, mb2.length);
+    }
+  }
+
+  //TODO: same for v3000 monomer
+
+  return [mb1, mb2];
+}
+
+function getSyntheticMolBlock(rdkit: RDModule, reaction: string,
+  mb1: string, mb2: string, monomerName: string): string {
+  let rxn: RDReaction | null = null;
+  let mols: MolList | null = null;
+  let mol1: RDMol | null = null;
+  let mol2: RDMol | null = null;
+  let rctns: RDReactionResult | null = null;
+  let molP: RDMol | null = null;
+  let molBlock = '';
+
+  try {
+    rxn = rdkit.get_rxn(reaction);
+    if (!rxn) throw new InvalidReactionError(reaction);
+    mols = new rdkit.MolList();
+    mol1 = rdkit.get_mol(mb1!);
+    mol2 = rdkit.get_mol(mb2!);
+    mols.append(mol1!);
+    mols.append(mol2!);
+
+    rctns = rxn.run_reactants(mols, 1);
+    //const size = rctns.size();
+    const element = rctns.get(0);
+
+    molP = element.next();
+    molBlock = molP?.get_molblock();//molP?.get_v3Kmolblock();//
+  } catch (err: any) {
+    const [errMsg, _errStack] = errInfo(err);
+    grok.shell.error(`Can not assemble monomer '${monomerName}': ${errMsg}.`);
+    throw err;
+  } finally {
+    rxn?.delete();
+    mols?.delete();
+    mol1?.delete();
+    mol2?.delete();
+    rctns?.delete();
+    molP?.delete();
+  }
+
+  return molBlock;
+}
+
+function getNewGroups(monomer1: Monomer, monomer2: Monomer): RGroup[] {
+  const groups = new Array<RGroup>(monomer1?.rgroups.length! + monomer2?.rgroups.length!);
+  const length1 = monomer1?.rgroups.length!;
+  const length2 = monomer2?.rgroups.length!;
+
+  for (let i = 0; i < length1; i++)
+    groups[i] = monomer1?.rgroups[i]!;
+
+  for (let i = 0; i < length2; i++) {
+    const rGroupSpecifier = monomer2?.rgroups[i]!.label.replace('R', '');
+    const groupPosition = Number(rGroupSpecifier) + length1;
+    const group: RGroup = {
+      //@ts-ignore
+      [HELM_RGROUP_FIELDS.CAP_GROUP_SMILES_UPPERCASE]: monomer2?.rgroups[i].capGroupSMILES.replace(rGroupSpecifier, String(groupPosition)),
+      [HELM_RGROUP_FIELDS.ALTERNATE_ID]: monomer2?.rgroups[i].alternateId.replace(rGroupSpecifier, String(groupPosition)),
+      [HELM_RGROUP_FIELDS.CAP_GROUP_NAME]: monomer2?.rgroups[i].capGroupName,
+      [HELM_RGROUP_FIELDS.LABEL]: monomer2?.rgroups[i].label.replace(rGroupSpecifier, String(groupPosition)),
+    };
+
+    groups[i + length1] = group;
+  }
+
+  return groups;
+}
+
+export function getNewMonomer(rdkit: RDModule, mLib: IMonomerLib, rule: RuleReaction): [string, Monomer] {
+  const reacSmarts = rule.reaction;
+  const monomerName = rule.name;
+
+  const monomer1 = mLib.getMonomer('PEPTIDE', rule.firstMonomer);
+  if (!monomer1) throw new MonomerNotFoundError('PEPTIDE', rule.firstMonomer);
+  const monomer2 = mLib.getMonomer('PEPTIDE', rule.secondMonomer);
+  if (!monomer2) throw new MonomerNotFoundError('PEPTIDE', rule.secondMonomer);
+
+  const [mb1, mb2] = getMonomersMolBlocks(monomer1!, monomer2!);
+  const molBlock = getSyntheticMolBlock(rdkit, reacSmarts, mb1, mb2, monomerName);
+  const groups: RGroup[] = getNewGroups(monomer1!, monomer2!);
+
+  const resMonomer: Monomer = {
+    [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];
+}
+
+export async function getOverriddenLibrary(rules: Rules): Promise<IMonomerLibBase> {
+  const monomerLibHelper = await getMonomerLibHelper();
+  const systemMonomerLib = monomerLibHelper.getMonomerLib();
+
+  const rdkit = await getRdKitModule();
+  const argLib: { [symbol: string]: Monomer } = {};
+
+  for (let i = 0; i < rules.reactionRules.length; i++) {
+    const [name, monomer] = getNewMonomer(rdkit, systemMonomerLib, rules.reactionRules[i]);
+    argLib[name] = monomer;
+  }
+
+  const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: argLib};
+  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,10 +9,13 @@ 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_PATH, RULES_STORAGE_NAME} from './pt-rules';
-import {doPolyToolConvert} from './pt-conversion';
+import {getRules, RuleInputs, Rules, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {doPolyToolConvert, getOverriddenLibrary} from './pt-conversion';
 import {defaultErrorHandler} from '../utils/err-info';
 import {getLibrariesList} from './utils';
 import {getEnumerationChem, PT_CHEM_EXAMPLE} from './pt-enumeration-chem';
@@ -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;
       }
     });
@@ -85,7 +88,7 @@ export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.D
     const chiralityEngineInput = ui.input.bool(PT_UI_USE_CHIRALITY, {value: false});
     let ruleFileList: string[];
     const ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json', {
-      onValueChanged: (value: string[]) => { ruleFileList = value;}
+      onValueChanged: (value: string[]) => { ruleFileList = value; }
     });
     const rulesHeader = ui.inlineText([PT_UI_RULES_USED]);
     ui.tooltip.bind(rulesHeader, 'Add or specify rules to use');
@@ -256,34 +259,24 @@ export async function polyToolConvert(
     if (generateHelm && table) table.columns.add(resHelmCol, true);
 
     const seqHelper: ISeqHelper = await getSeqHelper();
-    const toAtomicLevelRes = await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, /* highlight */ generateHelm);
+    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!;
 
-    // const rdkit = await grok.functions.call('Chem:getRdKitModule');
-    // for (let i = 0; i < rules.reactionRules.length; i++) {
-    //   const reacSmarts = rules.reactionRules[i].reaction;
-    //   const rxn = rdkit.get_rxn(reacSmarts);
-
-    //   for (let j = 0; j < resMolCol.length; j++) {
-    //     const mols = new rdkit.MolList();
-    //     const mol = rdkit.get_mol(resMolCol.get(j));
-    //     mols.append(mol!);
-    //     const rctns = rxn.run_reactants(mols, 1);
-    //     const size = rctns.size();
-    //     const element = rctns.get(0);
-    //     let molP: RDMol | null = null;
-    //     molP = element.next();
-    //     const molBlock = molP?.get_v3Kmolblock();
-    //     resMolCol.set(j, molBlock!);
-    //   }
-    // }
-
     resMolCol.name = getUnusedName(table, `molfile(${seqCol.name})`);
     resMolCol.semType = DG.SEMTYPE.MOLECULE;
     if (table) {
       table.columns.add(resMolCol, true);
       await grok.data.detectSemanticTypes(table);
     }
+
+    buildMonomerHoverLink(resHelmCol, resMolCol, lib, seqHelper, rdKitModule);
+
     return [resHelmCol, resMolCol];
   } finally {
     pi.close();

package/src/polytool/pt-enumeration-helm-dialog.ts

@@ -16,7 +16,6 @@ import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-he
 import '@datagrok-libraries/bio/src/types/input';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {InputColumnBase} from '@datagrok-libraries/bio/src/types/input';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
 import {
   PolyToolEnumeratorParams, PolyToolEnumeratorType, PolyToolEnumeratorTypes
@@ -36,8 +35,9 @@ type PolyToolEnumerateInputs = {
   placeholdersBreadth: PolyToolPlaceholdersBreadthInput;
   enumeratorType: DG.ChoiceInput<PolyToolEnumeratorType>
   trivialNameCol: InputColumnBase,
-  toAtomicLevel: DG.InputBase<boolean>;
   keepOriginal: DG.InputBase<boolean>;
+  toAtomicLevel: DG.InputBase<boolean>;
+  toHarmonizedSequence: DG.InputBase<boolean>;
 };
 
 type PolyToolEnumerateHelmSerialized = {
@@ -46,8 +46,9 @@ type PolyToolEnumerateHelmSerialized = {
   placeholdersBreadth: string;
   enumeratorType: PolyToolEnumeratorType;
   trivialNameCol: string;
-  toAtomicLevel: boolean;
   keepOriginal: boolean;
+  toAtomicLevel: boolean;
+  toHarmonizedSequence: boolean;
 };
 
 export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
@@ -160,10 +161,12 @@ async function getPolyToolEnumerateDialog(
           showRowHeader: false,
           showCellTooltip: false,
         }),
-      toAtomicLevel: ui.input.bool(
-        'To atomic level', {value: false}),
       keepOriginal: ui.input.bool(
         'Keep original', {value: false}),
+      toAtomicLevel: ui.input.bool(
+        'To atomic level', {value: false}),
+      toHarmonizedSequence: ui.input.bool(
+        'To harmonized sequence', {value: false}),
       trivialNameCol: ui.input.column2(
         'Trivial name', {
           table: cell?.dataFrame,
@@ -184,6 +187,7 @@ async function getPolyToolEnumerateDialog(
         }),
     };
 
+    inputs.toHarmonizedSequence.root.style.display = 'none';
     inputs.trivialNameCol.addOptions(trivialNameSampleDiv);
 
     let placeholdersValidity: string | null = null;
@@ -363,8 +367,9 @@ async function getPolyToolEnumerateDialog(
       let helmValue: string;
       let table: DG.DataFrame | undefined = undefined;
       if (cell && cell.rowIndex >= 0 && cell?.column.semType == DG.SEMTYPE.MACROMOLECULE) {
-        const sh = SeqHandler.forColumn(cell.column);
-        helmValue = await sh.getHelm(cell.rowIndex);
+        const sh = _package.seqHelper.getSeqHandler(cell.column);
+        const helmSemValue = await sh.getHelm(cell.rowIndex);
+        helmValue = helmSemValue.value;
         table = cell.dataFrame;
       } else {
         helmValue = PT_HELM_EXAMPLE;
@@ -414,8 +419,8 @@ async function getPolyToolEnumerateDialog(
       .add(inputs.enumeratorType)
       .add(inputs.placeholdersBreadth)
       .add(inputs.trivialNameCol)
-      .add(inputs.toAtomicLevel)
-      .add(inputs.keepOriginal)
+      .add(ui.divH([inputs.keepOriginal.root, inputs.toAtomicLevel.root, inputs.toHarmonizedSequence.root],
+        {style: {width: '100%'}}))
       .add(warningsTextDiv)
       // .addButton('Enumerate', () => {
       //   execDialog()
@@ -433,8 +438,9 @@ async function getPolyToolEnumerateDialog(
           enumeratorType: inputs.enumeratorType.value,
           placeholdersBreadth: inputs.placeholdersBreadth.stringValue,
           trivialNameCol: inputs.trivialNameCol.stringValue,
-          toAtomicLevel: inputs.toAtomicLevel.value,
           keepOriginal: inputs.keepOriginal.value,
+          toAtomicLevel: inputs.toAtomicLevel.value,
+          toHarmonizedSequence: inputs.toHarmonizedSequence.value,
         };
       },
       /* applyInput */ (x: PolyToolEnumerateHelmSerialized): void => {
@@ -443,8 +449,9 @@ async function getPolyToolEnumerateDialog(
         inputs.enumeratorType.value = x.enumeratorType;
         inputs.placeholdersBreadth.stringValue = x.placeholdersBreadth;
         inputs.trivialNameCol.stringValue = x.trivialNameCol;
-        inputs.toAtomicLevel.value = x.toAtomicLevel;
         inputs.keepOriginal.value = x.keepOriginal;
+        inputs.toAtomicLevel.value = x.toAtomicLevel;
+        inputs.toHarmonizedSequence.value = x.toHarmonizedSequence;
       });
     return dialog;
   } catch (err: any) {

package/src/polytool/pt-enumeration-helm.ts

@@ -4,7 +4,8 @@ import * as DG from 'datagrok-api/dg';
 
 import {
   HelmType, HelmMol,
-  JSDraw2ModuleType, OrgType
+  JSDraw2ModuleType, OrgType,
+  IHelmEditorOptions
 } from '@datagrok-libraries/bio/src/helm/types';
 
 
@@ -72,7 +73,7 @@ function getPtEnumeratorBreadth(m: HelmMol, placeholdersBreadth: PolyToolPlaceho
 export function doPolyToolEnumerateHelm(
   helm: string, id: string, params: PolyToolEnumeratorParams
 ): [ /* helm */ string, /* id */ string][] {
-  const molHandler = new JSDraw2.MolHandler<HelmType>();
+  const molHandler = new JSDraw2.MolHandler<HelmType, IHelmEditorOptions>();
   const plugin = new org.helm.webeditor.Plugin(molHandler);
   org.helm.webeditor.IO.parseHelm(plugin, helm, new JSDraw2.Point(0, 0), undefined);
   const m = molHandler.m;

package/src/polytool/pt-unrule-dialog.ts

@@ -4,7 +4,6 @@ import * as DG from 'datagrok-api/dg';
 
 import {Unsubscribable} from 'rxjs';
 
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getUnusedColName} from '@datagrok-libraries/bio/src/monomer-works/utils';
 
@@ -12,6 +11,7 @@ import {defaultErrorHandler} from '../utils/err-info';
 import {doPolyToolUnrule} from './pt-unrule';
 import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
 import {PT_ERROR_DATAFRAME, PT_UI_DIALOG_UNRULE, PT_UI_RULES_USED} from './const';
+import {_package} from '../package';
 
 type PolyToolUnruleSerialized = {
   rules: string[];
@@ -34,7 +34,7 @@ export async function getPolyToolUnruleDialog(srcCol?: DG.Column<string>): Promi
       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.HELM;
       }
     });