@datagrok/sequence-translator 1.5.2 → 1.6.0

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

@@ -0,0 +1,356 @@
+import {getInnerIdx, getOuterIdx, Linkage} from './pt-misc';
+import {cleanupHelmSymbol} from '@datagrok-libraries/bio/src/helm/utils';
+import {getMonomerPairs, RuleLink, RuleReaction, Rules} from './pt-rules';
+
+type LinkedPosition = {
+  firstIdx: number,
+  secondIdx: number,
+  ruleIdx: number
+}
+
+export function parseSeparator(sequence: string): [Linkage[], string[][]] {
+  const mainFragments: string[][] = [];
+  const linkages: Linkage[] = [];
+
+  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);
+    let spmCount: number = 0;
+    for (let j = 0; j < splMonomers.length; j++) {
+      const monomer = splMonomers[j].replace('{', '').replace('}', '');
+      if (monomer !== '') {
+        monomers[j] = monomer;
+        counter++;
+        spmCount++;
+      } else {
+        linkages.push({fChain: i, sChain: i + 1, fMonomer: counter, sMonomer: counter + 1, fR: 1, sR: 1});
+      }
+    }
+    mainFragments.push(monomers.slice(0, spmCount));
+  }
+
+  return [linkages, mainFragments];
+}
+
+export function parseHelm(sequence: string): [Linkage[], string[][]] {
+  const ea = /(\w+\{.*\})\$(.*)\$(.*)\$(.*)\$/g.exec(sequence)!;
+  // const fragmentation = helm.split('$');
+  const fragmentation = [ea[1], ea[2], ea[3], ea[4]];
+
+  const rawFragments = fragmentation[0].split('|');
+  const rawLinkages = fragmentation[1].split('|');
+
+  const monomers = new Array<Array<string>>(rawFragments.length);
+  const linkages: Linkage[] = [];
+
+  //HELM parsing
+  for (let i = 0; i < rawFragments.length; i++) {
+    const idxStart = rawFragments[i].indexOf('{');
+    const idxEnd = rawFragments[i].indexOf('}');
+
+    monomers[i] = rawFragments[i].slice(idxStart + 1, idxEnd).split('.').map((s) => cleanupHelmSymbol(s));
+  }
+
+  for (let i = 0; i < rawLinkages.length; i++) {
+    if (rawLinkages[i] !== '' && rawLinkages[i] !== 'V2.0') {
+      const rawData = rawLinkages[i].split(',');
+      const fChainIdx = parseInt(rawData[0].replace('PEPTIDE', '')) - 1;
+      const sChainIdx = parseInt(rawData[1].replace('PEPTIDE', '')) - 1;
+      const rawDataConnections = rawData[2].split('-');
+      const rawDataConnection1 = rawDataConnections[0].split(':');
+      const rawDataConnection2 = rawDataConnections[1].split(':');
+
+      linkages.push({
+        fChain: fChainIdx,
+        sChain: sChainIdx,
+        fMonomer: getOuterIdx(parseInt(rawDataConnection1[0]), fChainIdx, monomers),
+        sMonomer: getOuterIdx(parseInt(rawDataConnection2[0]), sChainIdx, monomers),
+        fR: parseInt(rawDataConnection1[1].replace('R', '')),
+        sR: parseInt(rawDataConnection2[1].replace('R', '')),
+      });
+    }
+  }
+
+  return [linkages, monomers];
+}
+
+export function fromObjectsToHelm(linkages: Linkage[], monomers: string[][]): string {
+  let helm = '';
+  for (let i = 0; i < monomers.length; i++) {
+    if (i > 0)
+      helm += '|';
+
+    helm += `PEPTIDE${i + 1}{`;
+
+    for (let j = 0; j < monomers[i].length; j++) {
+      if (j > 0)
+        helm += '.';
+      const symbol = monomers[i][j];
+      helm += symbol.length > 1 ? `[${symbol}]` : symbol;
+    }
+    helm += `}`;
+  }
+
+  helm += '$';
+
+  for (let i = 0; i < linkages.length; i++) {
+    if (i > 0)
+      helm += '|';
+    helm += `PEPTIDE${linkages[i].fChain + 1},PEPTIDE${linkages[i].sChain + 1},`;
+
+    helm += `${getInnerIdx(linkages[i].fMonomer - 1, monomers)[0] + 1}:R${linkages[i].fR}-`;
+    helm += `${getInnerIdx(linkages[i].sMonomer - 1, monomers)[0] + 1}:R${linkages[i].sR}`;
+  }
+
+  helm += '$$$' + 'V2.0';
+  return helm;
+}
+
+//homo and hetero dimers
+export function handleDuplicated(sequence: string, rules: Rules): [Linkage[], string[]] {
+  const mainFragments: string[] = [];
+  const linkages: Linkage[] = [];
+  const heterodimerCode = rules.heterodimerCode;
+  const homodimerCode = rules.homodimerCode;
+
+  //NOTICE: this works only with simple single heterodimers
+  const heterodimeric = heterodimerCode !== null ? sequence.split(`(${rules.heterodimerCode!})`) : '';
+  if (heterodimerCode !== null && heterodimeric.length > 1) {
+    linkages.push({fChain: 0, sChain: 1, fMonomer: 1, sMonomer: 1, fR: 1, sR: 1});
+    mainFragments.push(heterodimeric[1].replaceAll('{', '').replaceAll('}', ''));
+    mainFragments.push(heterodimeric[2].replaceAll('{', '').replaceAll('}', ''));
+  } else {
+    mainFragments.push(sequence);
+  }
+
+  //NOTICE: this works only with simple single dimers
+  for (let i = 0; i < mainFragments.length; i++) {
+    if (homodimerCode !== null && mainFragments[i].includes(`(${homodimerCode!})`)) {
+      const idxSequence = mainFragments.length;
+
+      linkages.push({fChain: i, sChain: idxSequence, fMonomer: 1, sMonomer: 1, fR: 1, sR: 1});
+      const rawDimer = mainFragments[i].replace(`(${homodimerCode!})`, '');
+      const idx = rawDimer.indexOf('{');
+      const linker = rawDimer.slice(0, idx);
+      const body = rawDimer.replace(linker, '').replaceAll('{', '').replaceAll('}', '');
+
+      mainFragments[i] = linker + body;
+      mainFragments.push(body);
+    }
+  }
+
+  for (let i = 0; i < mainFragments.length; i++) {
+    if (homodimerCode !== null && mainFragments[i].includes(`(${homodimerCode!})`)) {
+      const idxSequence = mainFragments.length;
+
+      linkages.push({fChain: i, sChain: idxSequence, fMonomer: 1, sMonomer: 1, fR: 1, sR: 1});
+      const rawDimer = mainFragments[i].replace(`(${homodimerCode!})`, '');
+      const idx = rawDimer.indexOf('{');
+      const linker = rawDimer.slice(0, idx);
+      const body = rawDimer.replace(linker, '').replaceAll('{', '').replaceAll('}', '');
+
+      mainFragments[i] = linker + body;
+      mainFragments.push(body);
+    }
+  }
+
+  return [linkages, mainFragments];
+}
+
+export function handleLinkRules(mf: string[], monomers: string[][], linkages: Linkage[], rules: Rules): void {
+  for (let i = 0; i < mf.length; i++) {
+    const rawMonomers = mf[i].split('-');
+    const linkedPositions = getLinkedPositions(rawMonomers, rules.linkRules);
+    const [allPos1, allPos2, allAttaches1, allAttaches2] =
+      getAllCycles(rules.linkRules, rawMonomers, linkedPositions);
+
+    for (let j = 0; j < allPos1.length; j++) {
+      linkages.push({
+        fChain: i,
+        sChain: i,
+        fMonomer: allPos1[j],
+        sMonomer: allPos2[j],
+        fR: allAttaches1[j],
+        sR: allAttaches2[j],
+      });
+    }
+
+    monomers[i] = rawMonomers;
+  }
+}
+
+export function handleReactionRules(monomers: string[][], linkages: Linkage[], rules: Rules): void {
+  for (let i = 0; i < monomers.length; i++) {
+    const linkedPositions = getLinkedPositions(monomers[i], rules.reactionRules);
+    const [allPos1, allPos2, ruleN] = getAllReactants(rules.reactionRules, monomers[i], linkedPositions);
+
+    if (allPos1.length >= 1) {
+      linkages.push({
+        fChain: i,
+        sChain: monomers.length,
+        fMonomer: allPos1[0],
+        sMonomer: 1,
+        fR: 3,
+        sR: 1,
+      });
+
+      linkages.push({
+        fChain: i,
+        sChain: monomers.length,
+        fMonomer: allPos2[0],
+        sMonomer: 1,
+        fR: 3,
+        sR: 2,
+      });
+
+      monomers.push([rules.reactionRules[ruleN[0]].name]);
+    }
+  }
+}
+
+function reset(): [boolean, boolean, boolean, number, number] {
+  return [false, false, false, -1, -1];
+}
+
+function find(monomers: string[], add: string, unlim: boolean, idx: number = 0,
+  firstMonomers: string[] = [], secondMonomers: string[] = []) : [boolean, boolean, boolean, number, number] {
+  let [firstFound, secondFound, firstIsFirst, firstIdx, secondIdx] = reset();
+  for (let k = 0; k < monomers.length; k++) {
+    if (monomers[k].includes(add)) {
+      if (firstFound) {
+        if (firstIsFirst && (unlim || monomers[k] == secondMonomers[idx] + add)) {
+          secondFound = true;
+          secondIdx = k;
+          break;
+        } else if (!firstIsFirst && (unlim || monomers[k] == firstMonomers[idx] + add)) {
+          secondFound = true;
+          secondIdx = k;
+          break;
+        } else {
+          continue;
+        }
+      } else if (unlim) {
+        firstFound = true;
+        firstIsFirst = true;
+        firstIdx = k;
+      } else {
+        if (monomers[k] == firstMonomers[idx] + add) {
+          firstFound = true;
+          firstIsFirst = true;
+          firstIdx = k;
+        } else if (monomers[k] == secondMonomers[idx] + add) {
+          firstFound = true;
+          firstIsFirst = unlim ? true : false;
+          firstIdx = k;
+        } else {
+          continue;
+        }
+      }
+    }
+  }
+
+  return [firstFound, secondFound, firstIsFirst, firstIdx, secondIdx];
+}
+
+function getLinkedPositions(monomers: string[], rules: RuleLink[] | RuleReaction []) : LinkedPosition[] {
+  const result: LinkedPosition[] = [];
+
+  for (let i = 0; i < rules.length; i++) {
+    const add = `(${rules[i].code})`;
+
+    const [firstMonomers, secondMonomers] = getMonomerPairs(rules[i]);
+
+    if (firstMonomers.length > 0) {
+      for (let j = 0; j < firstMonomers.length; j++) {
+        const [firstFound, secondFound, firstIsFirst, firstIdx, secondIdx] =
+          find(monomers, add, false, j, firstMonomers, secondMonomers);
+
+        if (!(firstFound && secondFound))
+          continue;
+        else if (firstIsFirst)
+          result.push({firstIdx: firstIdx, secondIdx: secondIdx, ruleIdx: i});
+        else
+          result.push({firstIdx: secondIdx, secondIdx: firstIdx, ruleIdx: i});
+      }
+    } else {
+      const [firstFound, secondFound, firstIsFirst, firstIdx, secondIdx] = find(monomers, add, true);
+
+      if (!(firstFound && secondFound))
+        continue;
+      else if (firstIsFirst)
+        result.push({firstIdx: firstIdx, secondIdx: secondIdx, ruleIdx: i});
+      else
+        result.push({firstIdx: secondIdx, secondIdx: firstIdx, ruleIdx: i});
+    }
+  }
+
+  return result;
+}
+
+function getAllCycles(rules: RuleLink[], monomers: string [], positions: LinkedPosition[]):
+[number [], number [], number [], number []] {
+  const allPos1: number [] = [];
+  const allPos2: number [] = [];
+  const allAttaches1: number [] = [];
+  const allAttaches2: number [] = [];
+  const count = positions.length;
+
+  for (let i = 0; i < count; i++) {
+    if (positions[i].firstIdx == -1)
+      continue;
+
+    const ruleNum = positions[i].ruleIdx;
+    const code = rules[ruleNum].code;
+
+    monomers[positions[i].firstIdx] = monomers[positions[i].firstIdx].replace(`(${code})`, '');
+    monomers[positions[i].secondIdx] = monomers[positions[i].secondIdx].replace(`(${code})`, '');
+
+    allPos1.push(positions[i].firstIdx + 1);
+    allPos2.push(positions[i].secondIdx + 1);
+    allAttaches1.push(rules[ruleNum].firstLinkingGroup);
+    allAttaches2.push(rules[ruleNum].secondLinkingGroup);
+  }
+
+  return [allPos1, allPos2, allAttaches1, allAttaches2];
+}
+
+function getAllReactants(rules: RuleReaction[], monomers: string [], positions: LinkedPosition[]):
+[number [], number [], number []] {
+  const allPos1: number [] = [];
+  const allPos2: number [] = [];
+  const rule: number [] = [];
+  const count = positions.length;
+
+  for (let i = 0; i < count; i++) {
+    if (positions[i].firstIdx == -1)
+      continue;
+    const fIdx = positions[i].firstIdx;
+    const sIdx = positions[i].secondIdx;
+
+    const ruleNum = positions[i].ruleIdx;
+    const code = rules[ruleNum].code;
+    monomers[fIdx] = monomers[fIdx].replace(`(${code})`, '') + `_${rules[ruleNum].name}`;
+    monomers[sIdx] = monomers[sIdx].replace(`(${code})`, '') + `_${rules[ruleNum].name}`;
+
+    allPos1.push(fIdx + 1);
+    allPos2.push(sIdx + 1);
+    rule.push(positions[i].ruleIdx);
+  }
+
+  return [allPos1, allPos2, rule];
+}

package/src/polytool/conversion/rule-manager.ts

@@ -106,7 +106,7 @@ export class RulesManager {
       const code = this.rules.linkRules[i].code;
       const [firstMonomers, secondMonomers] = getMonomerPairs(this.rules.linkRules[i]);
       for (let j = 0; j < firstMonomers.length; j++) {
-        const seq = `${firstMonomers[j]}(${code})-A-A-A-A-${secondMonomers[j]}(${code})-A`;
+        const seq = `${firstMonomers[j]}(${code})-A-A-A-A-${secondMonomers[j]}(${code})`;
         seqs.push(seq);
       }
     }

package/src/polytool/pt-dialog.ts

@@ -16,7 +16,7 @@ import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
 import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './conversion/pt-rules';
 import {doPolyToolConvert} from './conversion/pt-conversion';
-import {getOverriddenLibrary} from './conversion/pt-misc';
+import {getOverriddenLibrary} from './conversion/pt-synthetic';
 import {defaultErrorHandler} from '../utils/err-info';
 import {getLibrariesList} from './utils';
 import {getEnumerationChem, PT_CHEM_EXAMPLE} from './pt-enumeration-chem';

package/src/polytool/pt-enumerate-seq-dialog.ts

@@ -615,7 +615,7 @@ async function polyToolEnumerateSeq(
       const templateList: string[] = new Array<string>(resList.length);
       for (let rowIdx = 0; rowIdx < resList.length; rowIdx++) {
         const pseudoHelm = resList[rowIdx][0];
-        const chain = Chain.parseHelm(pseudoHelm, helmHelper);
+        const chain = Chain.fromHelm(pseudoHelm, helmHelper);
         templateList[rowIdx] = chain.getNotation();
       }
       enumCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'Enumerated', templateList);

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

@@ -9,9 +9,10 @@ import {
 } from '@datagrok-libraries/bio/src/helm/types';
 
 
-import {Chain, PtBio} from './conversion/pt-chain';
+import {PtBio} from './conversion/pt-tools-helmmol';
 import {getAvailableMonomers} from './utils';
-import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes, PolyToolPlaceholder, PolyToolBreadthPlaceholder} from './types';
+import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes,
+  PolyToolPlaceholder, PolyToolBreadthPlaceholder} from './types';
 
 // For example keep monomers presented in HELMCoreLibrary.json only (not [NH2])
 export const PT_HELM_EXAMPLE = 'PEPTIDE1{R.[Aca].T.G.H.F.G.A.A.Y.P.E.[meI]}$$$$';
@@ -97,14 +98,15 @@ export function doPolyToolEnumerateHelm(
   }
 
   let resBreadthMolList: HelmMol[] = [];
-  if (params.breadthPlaceholders) {
+  if (params.breadthPlaceholders)
     resBreadthMolList = getPtEnumeratorBreadth(molHandler.m, params.breadthPlaceholders);
-  }
+
   resMolList = resMolList.concat(resBreadthMolList);
 
   if (params.keepOriginal)
     resMolList = [m, ...resMolList];
 
-  const resList = resMolList.map<[string, string]>((m: HelmMol) => { return [org.helm.webeditor.IO.getHelm(m)!, m.name!]; });
+  const resList = resMolList
+    .map<[string, string]>((m: HelmMol) => { return [org.helm.webeditor.IO.getHelm(m)!, m.name!]; });
   return resList;
 }

package/src/polytool/pt-unrule.ts

@@ -27,10 +27,10 @@ export async function polyToolUnruleUI(): Promise<void> {
 export function doPolyToolUnrule(helms: string[], rules: Rules, helmHelper: IHelmHelper): string[] {
   const resHrzSeqList = new Array<string>(helms.length);
   for (let i = 0; i < helms.length; ++i) {
-    if (!helms[i])
+    if (!helms[i]) {
       resHrzSeqList[i] = '';
-    else {
-      const chain = Chain.parseHelm(helms[i], helmHelper);
+    } else {
+      const chain = Chain.fromHelm(helms[i], helmHelper);
       resHrzSeqList[i] = chain.getNotation();
     }
   }

package/src/tests/polytool-chain-from-notation-tests.ts

@@ -23,31 +23,31 @@ category('PolyTool: Chain', () => {
       },
       tgt: {
         templateChain: {monomerCount: [11], linkageCount: 0},
-        mmChain: {monomerCount: [11], linkageCount: 1}
-      },
-    },
-    'reaction1': {
-      data: {
-        templateSeq: 'R-F-azG(4)-T-G-H-F-Y-P-aG(4)-meI',
-        templateHelm: 'PEPTIDE1{R.F.[azG(4)].T.G.H.F.Y.P.[aG(4)].[meI]}$$$$V2.0',
-        mmHelm: 'PEPTIDE1{R.F.[GGaz].T.G.H.F.Y.P}|PEPTIDE2{[meI]}$PEPTIDE1,PEPTIDE1,3:R3-9:R2|PEPTIDE1,PEPTIDE2,3:R4-1:R1$$$V2.0',
-      },
-      tgt: {
-        templateChain: {monomerCount: [11], linkageCount: 0,},
-        mmChain: {monomerCount: [9, 1], linkageCount: 2,}
-      }
-    },
-    'reaction2': {
-      data: {
-        templateSeq: 'R-F-aG(4)-T-G-H-F-Y-P-azG(4)-meI',
-        templateHelm: 'PEPTIDE1{R.F.[aG(4)].T.G.H.F.Y.P.[azG(4)].[meI]}$$$$V2.0',
-        mmHelm: 'PEPTIDE1{R.F}|PEPTIDE2{T.G.H.F.Y.P.[GGaz].[meI]}$PEPTIDE1,PEPTIDE2,2:R2-7:R3|PEPTIDE2,PEPTIDE2,1:R1-7:R4,$$$V2.0',
+        mmChain: {monomerCount: [11], linkageCount: 0}
       },
-      tgt: {
-        templateChain: {monomerCount: [11], linkageCount: 0,},
-        mmChain: {monomerCount: [2, 8], linkageCount: 2,}
-      }
     },
+    // 'reaction1': {
+    //   data: {
+    //     templateSeq: 'R-F-azG(4)-T-G-H-F-Y-P-aG(4)-meI',
+    //     templateHelm: 'PEPTIDE1{R.F.[azG(4)].T.G.H.F.Y.P.[aG(4)].[meI]}$$$$V2.0',
+    //     mmHelm: 'PEPTIDE1{R.F.[azG_GGaz].T.G.H.F.Y.P.[aG_GGaz].[meI]}|PEPTIDE2{[GGaz]}$PEPTIDE1,PEPTIDE2,3:R3-1:R1|PEPTIDE1,PEPTIDE2,10:R3-1:R2$$$V2.0',
+    //   },
+    //   tgt: {
+    //     templateChain: {monomerCount: [11], linkageCount: 0},
+    //     mmChain: {monomerCount: [9, 1], linkageCount: 2}
+    //   }
+    // },
+    // 'reaction2': {
+    //   data: {
+    //     templateSeq: 'R-F-aG(4)-T-G-H-F-Y-P-azG(4)-meI',
+    //     templateHelm: 'PEPTIDE1{R.F.[aG(4)].T.G.H.F.Y.P.[azG(4)].[meI]}$$$$V2.0',
+    //     mmHelm: 'PEPTIDE1{R.F.[aG_GGaz].T.G.H.F.Y.P.[azG_GGaz].[meI]}|PEPTIDE2{[GGaz]}$PEPTIDE1,PEPTIDE2,3:R3-1:R2|PEPTIDE1,PEPTIDE2,10:R3-1:R1$$$V2.0',
+    //   },
+    // tgt: {
+    //   templateChain: {monomerCount: [11], linkageCount: 0},
+    //   mmChain: {monomerCount: [2, 8], linkageCount: 2}
+    // }
+    //},
     'dimerized1': {
       data: {
         templateSeq: '(#3)Succ-{A(CHOL)-F-C(1)-T-G-H-Y-P-C(1)-NH2}',
@@ -80,18 +80,19 @@ category('PolyTool: Chain', () => {
   for (const [testName, {data, tgt}] of Object.entries(tests)) {
     test(`fromNotation-${testName}`, async () => {
       const rules = await getRules(['rules_example.json']);
-      const resMmChain = Chain.fromNotation(data.templateSeq, rules, helmHelper);
+      const resMmChain = Chain.fromSeparator(data.templateSeq, helmHelper);
+      resMmChain.applyRules(rules);
       resMmChain.check(true);
       expectArray(resMmChain.monomers.map((mL) => mL.length), tgt.mmChain.monomerCount);
       expect(resMmChain.linkages.length, tgt.mmChain.linkageCount);
       expect(resMmChain.getHelm(), data.mmHelm);
-    }, testName == 'reaction2' ? {skipReason: 'reverse reaction'} : undefined);
+    }, {skipReason: '3157'});
   }
 
   for (const [testName, {data, tgt}] of Object.entries(tests)) {
     test(`parseNotation-${testName}`, async () => {
       const rules = await getRules(['rules_example.json']);
-      const resTemplateChain = Chain.parseNotation(data.templateSeq, helmHelper);
+      const resTemplateChain = Chain.fromSeparator(data.templateSeq, helmHelper);
       resTemplateChain.check(true);
       expectArray(resTemplateChain.monomers.map((mL) => mL.length), tgt.templateChain.monomerCount);
       expect(resTemplateChain.linkages.length, tgt.templateChain.linkageCount);
@@ -103,7 +104,7 @@ category('PolyTool: Chain', () => {
   for (const [testName, {data, tgt}] of Object.entries(tests)) {
     test(`parseHelm-${testName}`, async () => {
       const rules = await getRules(['rules_example.json']);
-      const resTemplateChain = Chain.parseHelm(data.templateHelm, helmHelper);
+      const resTemplateChain = Chain.fromHelm(data.templateHelm, helmHelper);
       resTemplateChain.check(true);
       expectArray(resTemplateChain.monomers.map((mL) => mL.length), tgt.templateChain.monomerCount);
       expect(resTemplateChain.linkages.length, tgt.templateChain.linkageCount);
@@ -115,12 +116,12 @@ category('PolyTool: Chain', () => {
   for (const [testName, {data, tgt}] of Object.entries(tests)) {
     test(`applyRules-${testName}`, async () => {
       const rules = await getRules(['rules_example.json']);
-      const resTemplateChain = Chain.parseNotation(data.templateSeq, helmHelper);
-      const resMmChain = await resTemplateChain.applyRules(rules);
-      resMmChain.check(true);
-      expectArray(resMmChain.monomers.map((mL) => mL.length), tgt.mmChain.monomerCount);
-      expect(resMmChain.linkages.length, tgt.mmChain.linkageCount);
-      expect(resMmChain.getHelm(), data.mmHelm);
+      const resTemplateChain = Chain.fromSeparator(data.templateSeq, helmHelper);
+      resTemplateChain.applyRules(rules);
+      resTemplateChain.check(true);
+      expectArray(resTemplateChain.monomers.map((mL) => mL.length), tgt.mmChain.monomerCount);
+      expect(resTemplateChain.linkages.length, tgt.mmChain.linkageCount);
+      expect(resTemplateChain.getHelm(), data.mmHelm);
     }, {skipReason: 'applyRules is not implemented'});
   }
 });

package/src/tests/polytool-chain-parse-notation-tests.ts

@@ -49,7 +49,7 @@ category('PolyTool: Chain: parseNotation', () => {
   for (const [testName, testData] of Object.entries(tests)) {
     test(`${testName}`, async () => {
       const rules = await getRules(['rules_example.json']);
-      const resChain = await Chain.parseNotation(testData.src.seq, helmHelper);
+      const resChain = await Chain.fromSeparator(testData.src.seq, helmHelper);
       //expectArray(resChain.monomers.map((mL) => mL.length), testData.tgt.monomerCount);
       //expect(resChain.linkages.length, testData.tgt.linkageCount);
       // expect(resChain.getNotationHelm(), testData.tgt.helm);
@@ -60,7 +60,7 @@ category('PolyTool: Chain: parseNotation', () => {
       hwe.editor.setMol(resMol!);
       const resMolHelm = hwe.editor.getHelm();
 
-      const resHelm = resChain.getNotationHelm();
+      const resHelm = resChain.getHelm();
 
       expect(resMolHelm, testData.tgt.helm);
       expect(resHelm, testData.tgt.helm);

package/src/tests/polytool-convert-tests.ts

@@ -16,7 +16,7 @@ import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {doPolyToolConvert} from '../polytool/conversion/pt-conversion';
-import {getOverriddenLibrary} from '../polytool/conversion/pt-misc';
+import {getOverriddenLibrary} from '../polytool/conversion/pt-synthetic';
 import {getRules} from '../polytool/conversion/pt-rules';
 
 
@@ -49,51 +49,51 @@ category('PolyTool: Convert', () => {
       src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI'},
       tgt: {
         helm: 'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$V2.0',
-        mol: {atomCount: 95, bondCount: 100, inchiKey: 'LMJUFVBPWWJJPN-AJJYTACESA-N',},
+        mol: {atomCount: 95, bondCount: 100, inchiKey: 'LMJUFVBPWWJJPN-AJJYTACESA-N'},
       }
     },
     'cyclized-C(1)-0-1': {
       src: {seq: 'C(1)-T-G-H-F-Y-P-C(1)-meI'},
       tgt: {
         helm: 'PEPTIDE1{C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,1:R3-8:R3$$$V2.0',
-        mol: {atomCount: 73, bondCount: 77, inchiKey: 'KLFRBMUPPMMGJM-HXTBFBBASA-N',},
+        mol: {atomCount: 73, bondCount: 77, inchiKey: 'KLFRBMUPPMMGJM-HXTBFBBASA-N'},
       }
     },
     'cyclized-C(1)-2-0': {
       src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)'},
       tgt: {
         helm: 'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$V2.0',
-        mol: {atomCount: 86, bondCount: 91, inchiKey: 'WIHSRTQGMICACU-DDDKLKPZSA-N',},
+        mol: {atomCount: 86, bondCount: 91, inchiKey: 'WIHSRTQGMICACU-DDDKLKPZSA-N'},
       }
     },
     'cyclized-C(1)-0-0': {
       src: {seq: 'C(1)-T-G-H-F-Y-P-C(1)'},
       tgt: {
         helm: 'PEPTIDE1{C.T.G.H.F.Y.P.C}$PEPTIDE1,PEPTIDE1,1:R3-8:R3$$$V2.0',
-        mol: {atomCount: 64, bondCount: 68, inchiKey: 'LOSMDBLEXLWPLB-OFZKBENXSA-N',},
+        mol: {atomCount: 64, bondCount: 68, inchiKey: 'LOSMDBLEXLWPLB-OFZKBENXSA-N'},
       }
     },
     'cyclized-D(2)-NH2(2)-3-0': {
       src: {seq: 'R-F-D(2)-T-G-H-F-Y-P-NH2(2)'},
       tgt: {
         helm: 'PEPTIDE1{R.F.D.T.G.H.F.Y.P.[NH2]}$PEPTIDE1,PEPTIDE1,10:R2-3:R3$$$V2.0',
-        mol: {atomCount: 81, bondCount: 86, inchiKey: 'CBMGNYKOZWNVNK-AHGCAHLCSA-N',},
+        mol: {atomCount: 81, bondCount: 86, inchiKey: 'CBMGNYKOZWNVNK-AHGCAHLCSA-N'},
       }
     },
     'cyclized-D(2)-NH2(2)-0-0': {
       src: {seq: 'D(2)-T-G-H-F-Y-P-NH2(2)'},
       tgt: {
         helm: 'PEPTIDE1{D.T.G.H.F.Y.P.[NH2]}$PEPTIDE1,PEPTIDE1,8:R2-1:R3$$$V2.0',
-        mol: {atomCount: 59, bondCount: 63, inchiKey: 'HGRHAUQBJXFERJ-MUFWPYSASA-N',},
-      }
-    },
-    'cyclized-azG(4)-aG(4)-2-1': {
-      src: {seq: 'R-F-azG(4)-T-G-H-F-Y-P-aG(4)-meI'},
-      tgt: {
-        helm: 'PEPTIDE1{R.F.[GGaz].T.G.H.F.Y.P}|PEPTIDE2{[meI]}$PEPTIDE1,PEPTIDE1,3:R3-9:R2|PEPTIDE1,PEPTIDE2,3:R4-1:R1$$$V2.0',
-        mol: {atomCount: 97, bondCount: 103, inchiKey: 'WJSYGVBGPCCSJF-PERUNASMSA-N',},
+        mol: {atomCount: 59, bondCount: 63, inchiKey: 'HGRHAUQBJXFERJ-MUFWPYSASA-N'},
       }
     },
+    // 'cyclized-azG(4)-aG(4)-2-1': {
+    //   src: {seq: 'R-F-azG(4)-T-G-H-F-Y-P-aG(4)-meI'},
+    //   tgt: {
+    //     helm: 'PEPTIDE1{R.F.[azG_GGaz].T.G.H.F.Y.P.[aG_GGaz].[meI]}|PEPTIDE2{[GGaz]}$PEPTIDE1,PEPTIDE2,3:R3-1:R1|PEPTIDE1,PEPTIDE2,10:R3-1:R2$$$V2.0',
+    //     mol: {atomCount: 97, bondCount: 103, inchiKey: 'WJSYGVBGPCCSJF-PERUNASMSA-N'},
+    //   }
+    // },
   };
 
   for (const [testName, testData] of Object.entries(tests)) {

package/src/tests/polytool-detectors-custom-notation-test.ts

@@ -38,6 +38,6 @@ category('PolyTool: detectors', () => {
         await _testPos(reader, posColName, seqHelper, posCol.units, posCol.aligned,
           posCol.alphabet, posCol.alphabetSize, posCol.alphabetIsMultichar, posCol.separator);
       }
-    });
+    }, {skipReason: '3156'});
   }
 });

package/src/tests/toAtomicLevel-tests.ts

@@ -15,7 +15,7 @@ import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
 import {_package} from '../package-test';
-import {getNewMonomers} from '../polytool/conversion/pt-misc';
+import {getNewMonomers} from '../polytool/conversion/pt-synthetic';
 import {getRules, RuleReaction} from '../polytool/conversion/pt-rules';
 
 category('toAtomicLevel', () => {
@@ -79,14 +79,14 @@ category('toAtomicLevel', () => {
     const reactionRule = rules.reactionRules.find((r) => r.name == 'GGaz')!;
 
     const [newSymbols, newMonomers] = getNewMonomers(rdKitModule, systemMonomerLib, reactionRule);
-    expect(newSymbols[0], reactionRule.name);
+    expect(newSymbols[0], 'azG_GGaz');
 
     const mol = rdKitModule.get_mol(newMonomers[0].molfile);
     try {
       const molInchi = mol.get_inchi();
       const molInchiKey = rdKitModule.get_inchikey_for_inchi(molInchi);
-      expect(mol.get_num_bonds(), 18);
-      expect(mol.get_num_atoms(), 18);
+      expect(mol.get_num_bonds(), 6);
+      expect(mol.get_num_atoms(), 7);
       // TODO: Check inchi key for the new monomer molfile
       // expect(molInchiKey, 'V2H10N2O3S-UHFFFAOYSA-N');
     } finally {