@datagrok/sequence-translator 1.4.8 → 1.5.0

package/src/polytool/{pt-conversion.ts → conversion/pt-chain.ts}

@@ -1,24 +1,10 @@
-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 {cleanupHelmSymbol} from '@datagrok-libraries/bio/src/helm/utils';
-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 {HelmAtom, HelmBio, HelmMol, HelmType, JSDraw2ModuleType, OrgType} from '@datagrok-libraries/bio/src/helm/types';
+import {Atom, IHelmBio, HelmMol, HelmType, JSDraw2ModuleType, OrgType} from '@datagrok-libraries/bio/src/helm/types';
 import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {cleanupHelmSymbol} from '@datagrok-libraries/bio/src/helm/utils';
 
-import {Rules, RuleLink, RuleReaction} from './pt-rules';
-import {InvalidReactionError, MonomerNotFoundError} from './types';
-
-import {_package} from '../package';
+import {getOuterIdx, getInnerIdx} from './pt-misc';
+import {Rules, RuleLink, RuleReaction, getMonomerPairs} from './pt-rules';
 
 declare const JSDraw2: JSDraw2ModuleType;
 declare const org: OrgType;
@@ -31,8 +17,9 @@ type Linkage = {
   fR: number,
   sR: number
 }
+export type PtBio = IHelmBio & { i: number, j: number };
 
-type PolyToolBio = HelmBio & { i: number, j: number };
+type PtAtom = Atom<HelmType, PtBio>
 
 export class Chain {
   linkages: Linkage[];
@@ -40,9 +27,9 @@ export class Chain {
   mol: HelmMol;
 
   constructor(
-    monomers: string[][],
-    linkages: Linkage[],
-    mol: HelmMol) {
+    monomers: string[][], linkages: Linkage[], mol: HelmMol,
+    protected helmHelper: IHelmHelper,
+  ) {
     this.linkages = linkages;
     this.monomers = monomers;
     this.mol = mol;
@@ -73,14 +60,14 @@ export class Chain {
       monomers[i] = rawFragments[i].slice(idxStart + 1, idxEnd).split('.').map((s) => cleanupHelmSymbol(s));
       for (let j = 0; j < monomers[i].length; j++) {
         const elem = monomers[i][j];
-        const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
-        const atom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+        const bio: PtBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+        const atom = new JSDraw2.Atom<HelmType, IHelmBio>(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);
+          const bond = new JSDraw2.Bond<HelmType, IHelmBio>(atom1, atom2);
           bond.r1 = 2;
           bond.r2 = 1;
           resMol.addBond(bond);
@@ -116,29 +103,21 @@ export class Chain {
     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);
+      const bond = new JSDraw2.Bond<HelmType, IHelmBio>(atom1, atom2);
       bond.r1 = linkages[i].fR;
       bond.r2 = linkages[i].sR;
       resMol.addBond(bond);
     }
 
-    return new Chain(monomers, linkages, resMol);
+    return new Chain(monomers, linkages, resMol, helmHelper);
   }
 
   /** Get macromolecule from harmonized sequence (template) */
   applyRules(rules: Rules): Chain {
-    // Clone this
-    const resMonomers: string[][] = this.monomers.map((mL) => [...mL]);
-    const resLinkages: Linkage[] = [...this.linkages];
-    const resMol: HelmMol = this.mol.clone();
-
-    throw new Error('not implemented');
-
-    const chain = new Chain(resMonomers, resLinkages, resMol);
-    return chain;
+    const newNotation = this.getNotation();
+    return Chain.fromNotation(newNotation, rules, this.helmHelper);
   }
 
-  /** @deprecated Use {@link parseNotation} and {@link applyRules} instead. */
   static fromNotation(sequence: string, rules: Rules, helmHelper: IHelmHelper): Chain {
     const heterodimerCode = rules.heterodimerCode;
     const homodimerCode = rules.homodimerCode;
@@ -230,14 +209,14 @@ export class Chain {
         const ch2 = new Array<string>(monomersCycled.length - allPos2[0]);
         for (let j = 0; j < allPos2[0] - 1; j++) {
           const elem = ch1[j] = monomersCycled[j];
-          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
-          const atom: HelmAtom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          const bio: PtBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+          const atom: PtAtom = new JSDraw2.Atom<HelmType, PtBio>(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);
+            const bond = new JSDraw2.Bond<HelmType, IHelmBio>(atom1, atom2);
             bond.r1 = 2;
             bond.r2 = 1;
             resMol.addBond(bond);
@@ -247,14 +226,14 @@ export class Chain {
 
         for (let j = allPos2[0]; j < monomersCycled.length; j++) {
           const elem = ch2[j - allPos2[0]] = monomersCycled[j];
-          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
-          const atom: HelmAtom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          const bio: PtBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+          const atom: PtAtom = new JSDraw2.Atom<HelmType, PtBio>(p, elem, bio);
           resMol.addAtom(atom);
 
           if (j > allPos2[0]) {
             const atom1 = resMol.atoms[counter - 1];
             const atom2 = resMol.atoms[counter];
-            const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+            const bond = new JSDraw2.Bond<HelmType, IHelmBio>(atom1, atom2);
             bond.r1 = 2;
             bond.r2 = 1;
             resMol.addBond(bond);
@@ -304,14 +283,14 @@ export class Chain {
       } else {
         for (let j = 0; j < monomers[i].length; j++) {
           const elem = monomers[i][j];
-          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
-          const atom: HelmAtom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          const bio: PtBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+          const atom: PtAtom = new JSDraw2.Atom<HelmType, PtBio>(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);
+            const bond = new JSDraw2.Bond<HelmType, IHelmBio>(atom1, atom2);
             bond.r1 = 2;
             bond.r2 = 1;
             resMol.addBond(bond);
@@ -325,13 +304,13 @@ export class Chain {
     for (const l of linkages) {
       const atom1 = resMol.atoms[l.fMonomer - 1];
       const atom2 = resMol.atoms[l.sMonomer - 1];
-      const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+      const bond = new JSDraw2.Bond<HelmType, IHelmBio>(atom1, atom2);
       bond.r1 = l.fR;
       bond.r2 = l.sR;
       resMol.addBond(bond);
     }
 
-    const chain = new Chain(monomersAll, linkages, resMol);
+    const chain = new Chain(monomersAll, linkages, resMol, helmHelper);
     return chain;
   }
 
@@ -382,14 +361,14 @@ export class Chain {
       for (let j = 0; j < mainFragments[i].length; j++) {
         if (!!mainFragments[i][j]) {
           const elem = mainFragments[i][j];
-          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
-          const atom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          const bio: PtBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+          const atom = new JSDraw2.Atom<HelmType, IHelmBio>(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);
+            const bond = new JSDraw2.Bond<HelmType, IHelmBio>(atom1, atom2);
             bond.r1 = 2;
             bond.r2 = 1;
             resMol.addBond(bond);
@@ -405,13 +384,13 @@ export class Chain {
     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);
+      const bond = new JSDraw2.Bond<HelmType, IHelmBio>(atom1, atom2);
       bond.r1 = linkages[i].fR;
       bond.r2 = linkages[i].sR;
       resMol.addBond(bond);
     }
 
-    const chain = new Chain(mainFragments, linkages, resMol);
+    const chain = new Chain(mainFragments, linkages, resMol, helmHelper);
     return chain;
   }
 
@@ -544,7 +523,7 @@ export class Chain {
 
   protected static getLinkedPositions(monomers: string[], rules: RuleLink[] | RuleReaction []):
     [number, number, number][] {
-    const result: [number, number, number][] = new Array<[number, number, number]>(rules.length);
+    const result: [number, number, number][] = [];
 
     for (let i = 0; i < rules.length; i++) {
       let firstFound = false;
@@ -553,42 +532,78 @@ export class Chain {
       let firstEntryIndex = -1;
       let secondEntryIndex = -1;
       const add = `(${rules[i].code})`;
-      for (let j = 0; j < monomers.length; j++) {
-        if (monomers[j].includes(add)) {
-          if (firstFound) {
-            if (firstIsFirst && monomers[j] == rules[i].secondMonomer + add) {
-              secondFound = true;
-              secondEntryIndex = j;
-              break;
-            } else if (!firstIsFirst && monomers[j] == rules[i].firstMonomer + add) {
-              secondFound = true;
-              secondEntryIndex = j;
-              break;
-            } else {
-              continue;
+
+      const [firstMonomers, secondMonomers] = getMonomerPairs(rules[i]);
+
+      if (firstMonomers.length > 0) {
+        for (let j = 0; j < firstMonomers.length; j++) {
+          for (let k = 0; k < monomers.length; k++) {
+            if (monomers[k].includes(add)) {
+              if (firstFound) {
+                if (firstIsFirst && monomers[k] == secondMonomers[j] + add) {
+                  secondFound = true;
+                  secondEntryIndex = k;
+                  break;
+                } else if (!firstIsFirst && monomers[k] == firstMonomers[j] + add) {
+                  secondFound = true;
+                  secondEntryIndex = k;
+                  break;
+                } else {
+                  continue;
+                }
+              } else {
+                if (monomers[k] == firstMonomers[j] + add) {
+                  firstFound = true;
+                  firstIsFirst = true;
+                  firstEntryIndex = k;
+                } else if (monomers[k] == secondMonomers[j] + add) {
+                  firstFound = true;
+                  firstIsFirst = false;
+                  firstEntryIndex = k;
+                } else {
+                  continue;
+                }
+              }
             }
-          } else {
-            if (monomers[j] == rules[i].firstMonomer + add) {
+          }
+
+          if (!(firstFound && secondFound))
+            continue;
+          else if (firstIsFirst)
+            result.push([firstEntryIndex, secondEntryIndex, i]);
+          else
+            result.push([secondEntryIndex, firstEntryIndex, i]);
+        }
+      } else {
+        for (let k = 0; k < monomers.length; k++) {
+          if (monomers[k].includes(add)) {
+            if (firstFound) {
+              if (firstIsFirst && monomers[k]) {
+                secondFound = true;
+                secondEntryIndex = k;
+                break;
+              } else if (!firstIsFirst && monomers[k]) {
+                secondFound = true;
+                secondEntryIndex = k;
+                break;
+              } else {
+                continue;
+              }
+            } else {
               firstFound = true;
               firstIsFirst = true;
-              firstEntryIndex = j;
-            } else if (monomers[j] == rules[i].secondMonomer + add) {
-              firstFound = true;
-              firstIsFirst = false;
-              firstEntryIndex = j;
-            } else {
-              continue;
+              firstEntryIndex = k;
             }
           }
         }
-      }
 
-      if (!(firstFound && secondFound))
-        result[i] = [-1, -1, -1];
-      else if (firstIsFirst)
-        result[i] = [firstEntryIndex, secondEntryIndex, i];
-      else
-        result[i] = [secondEntryIndex, firstEntryIndex, i];
+        if (!(firstFound && secondFound))
+          continue;
+        else if (firstIsFirst)
+          result.push([firstEntryIndex, secondEntryIndex, i]);
+        else
+          result.push([secondEntryIndex, firstEntryIndex, i]);
+      }
     }
 
     return result;
@@ -600,21 +615,22 @@ export class Chain {
     const allPos2: number [] = [];
     const allAttaches1: number [] = [];
     const allAttaches2: number [] = [];
-    const ruleCount = rules.length;
+    const count = positions.length;
 
-    for (let i = 0; i < ruleCount; i++) {
+    for (let i = 0; i < count; i++) {
       if (positions[i][0] == -1)
         continue;
 
-      const firstMonomer = monomers[positions[i][0]];
-      const secondMonomer = monomers[positions[i][1]];
-      monomers[positions[i][0]] = monomers[positions[i][0]].replace(firstMonomer, rules[i].firstSubstitution);
-      monomers[positions[i][1]] = monomers[positions[i][1]].replace(secondMonomer, rules[i].secondSubstitution);
+      const ruleNum = positions [i][2];
+      const code = rules[ruleNum].code;
+
+      monomers[positions[i][0]] = monomers[positions[i][0]].replace(`(${code})`, '');
+      monomers[positions[i][1]] = monomers[positions[i][1]].replace(`(${code})`, '');
 
       allPos1.push(positions[i][0] + 1);
       allPos2.push(positions[i][1] + 1);
-      allAttaches1.push(rules[i].firstLinkingGroup);
-      allAttaches2.push(rules[i].secondLinkingGroup);
+      allAttaches1.push(rules[ruleNum].firstLinkingGroup);
+      allAttaches2.push(rules[ruleNum].secondLinkingGroup);
     }
 
     return [monomers, allPos1, allPos2, allAttaches1, allAttaches2];
@@ -625,16 +641,16 @@ export class Chain {
     const allPos1: number [] = [];
     const allPos2: number [] = [];
     const rule: number [] = [];
-    const ruleCount = rules.length;
+    const count = positions.length;
 
-    for (let i = 0; i < ruleCount; i++) {
+    for (let i = 0; i < count; i++) {
       if (positions[i][0] == -1)
         continue;
 
-      const firstMonomer = monomers[positions[i][0]];
-      const secondMonomer = monomers[positions[i][1]];
-      monomers[positions[i][0]] = monomers[positions[i][0]].replace(firstMonomer, rules[i].firstMonomer);
-      monomers[positions[i][1]] = monomers[positions[i][1]].replace(secondMonomer, rules[i].secondMonomer);
+      const ruleNum = positions [i][2];
+      const code = rules[ruleNum].code;
+      monomers[positions[i][0]] = monomers[positions[i][0]].replace(`(${code})`, '');
+      monomers[positions[i][1]] = monomers[positions[i][1]].replace(`(${code})`, '');
 
       allPos1.push(positions[i][0] + 1);
       allPos2.push(positions[i][1] + 1);
@@ -648,15 +664,17 @@ export class Chain {
     const errors: string[] = [];
 
     const chainsMonomerCount = this.monomers.map((ch) => ch.length).reduce((acc, curr) => acc + curr, 0);
-    if (this.mol.atoms.length !== chainsMonomerCount)
+    if (this.mol.atoms.length !== chainsMonomerCount) {
       errors.push(`The mol atoms count ${this.mol.atoms.length} does not match ` +
         `the total number ${chainsMonomerCount} of chains' monomers.`);
+    }
 
     const internalBondsCount = this.monomers.map((ch) => ch.length - 1).reduce((acc, curr) => acc + curr, 0);
     const chainsBondCount = internalBondsCount + this.linkages.length;
-    if (this.mol.bonds.length !== chainsBondCount)
+    if (this.mol.bonds.length !== chainsBondCount) {
       errors.push(`The mol bonds count ${this.mol.bonds.length} does not match ` +
         `the total number ${chainsBondCount} in- and inter-chain linkages.`);
+    }
 
     let counter: number = 0;
     for (let spIdx = 0; spIdx < this.monomers.length; ++spIdx) {
@@ -677,188 +695,3 @@ export class Chain {
     return errors;
   }
 }
-
-/** The main PolyTool convert engine. Returns list of Helms. Covered with tests. */
-export function doPolyToolConvert(sequences: string[], rules: Rules, helmHelper: IHelmHelper): string[] {
-  const helms = new Array<string>(sequences.length);
-  for (let i = 0; i < sequences.length; i++) {
-    try {
-      if (sequences[i] == null) { helms[i] = ''; } else {
-        const chain = Chain.fromNotation(sequences[i], rules, helmHelper);
-        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;
-}
-
-/** Gets 0-based in-index (simple polymer) of out-index (continuous) {@link idx} */
-export function getInnerIdx(outIdx: number, monomers: string[][]): [number, number] {
-  // let prevSpCount = 0;
-  // for (let spI = 0; spI < monomers.length && idx >= (prevSpCount + monomers[spI].length); ++spI)
-  //   prevSpCount += monomers[spI].length;
-  // return idx - prevSpCount;
-  let inIdx = outIdx;
-  let spIdx: number;
-  for (spIdx = 0; spIdx < monomers.length && inIdx >= monomers[spIdx].length; ++spIdx)
-    inIdx -= monomers[spIdx].length;
-  return [inIdx, spIdx];
-}
-
-/** Gets 0-based out-index of 0-based in-index {@link inIdx} monomer of simple polymer {@link spIdx} */
-export function getOuterIdx(inIdx: number, spIdx: number, monomers: string[][]): number {
-  let outIdx = 0;
-  for (let i = 0; i < spIdx; ++i)
-    outIdx += monomers[i].length;
-  return outIdx + inIdx;
-}

package/src/polytool/conversion/pt-conversion.ts

@@ -0,0 +1,26 @@
+
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+
+import {Rules} from './pt-rules';
+import {Chain} from './pt-chain';
+
+import {_package} from '../../package';
+
+/** The main PolyTool convert engine. Returns list of Helms. Covered with tests. */
+export function doPolyToolConvert(sequences: string[], rules: Rules, helmHelper: IHelmHelper): string[] {
+  const helms = new Array<string>(sequences.length);
+  for (let i = 0; i < sequences.length; i++) {
+    try {
+      if (sequences[i] == null) { helms[i] = ''; } else {
+        const chain = Chain.fromNotation(sequences[i], rules, helmHelper);
+        helms[i] = chain.getHelm();
+      }
+    } catch (err: any) {
+      const [errMsg, errStack] = errInfo(err);
+      _package.logger.error(errMsg, undefined, errStack);
+      helms[i] = '';
+    }
+  }
+  return helms;
+}