@datagrok/bio 2.11.33 → 2.11.35

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.11.33",
+  "version": "2.11.35",
   "description": "Bioinformatics support (import/export of sequences, conversion, visualization, analysis). [See more](https://github.com/datagrok-ai/public/blob/master/packages/Bio/README.md) for details.",
   "repository": {
     "type": "git",
@@ -34,7 +34,7 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.39.25",
+    "@datagrok-libraries/bio": "5.39.26",
     "@datagrok-libraries/chem-meta": "^1.2.1",
     "@datagrok-libraries/ml": "^6.4.10",
     "@datagrok-libraries/tutorials": "^1.3.11",
@@ -44,7 +44,7 @@
     "@datagrok-libraries/math": "^1.0.7",
     "cash-dom": "^8.0.0",
     "css-loader": "^6.7.3",
-    "datagrok-api": "^1.17.13",
+    "datagrok-api": "^1.17.4",
     "dayjs": "^1.11.4",
     "fastest-levenshtein": "^1.0.16",
     "openchemlib": "6.0.1",

package/src/package.ts

@@ -60,6 +60,7 @@ import {getCompositionAnalysisWidget} from './widgets/composition-analysis-widge
 import {MacromoleculeColumnWidget} from './utils/macromolecule-column-widget';
 import {addCopyMenuUI} from './utils/context-menu';
 import {getPolyToolDialog} from './utils/poly-tool/ui';
+import {PolyToolCsvLibHandler} from './utils/poly-tool/csv-to-json-monomer-lib-converter';
 import {_setPeptideColumn} from './utils/poly-tool/utils';
 import {getRegionDo} from './utils/get-region';
 import {GetRegionApp} from './apps/get-region-app';
@@ -1018,6 +1019,17 @@ export async function polyToolColumnChoice(df: DG.DataFrame, macroMolecule: DG.C
   await grok.data.detectSemanticTypes(df);
 }
 
+//name: createMonomerLibraryForPolyTool
+//input: file file
+export async function createMonomerLibraryForPolyTool(file: DG.FileInfo) {
+  const fileContent = await file.readAsString();
+  const libHandler = new PolyToolCsvLibHandler(file.fileName, fileContent);
+  const libObject = await libHandler.getJson();
+  const jsonFileName = file.fileName.replace(/\.csv$/, '.json');
+  const jsonFileContent = JSON.stringify(libObject, null, 2);
+  DG.Utils.download(jsonFileName, jsonFileContent);
+}
+
 //name: SDF to JSON Library
 //input: dataframe table
 export async function sdfToJsonLib(table: DG.DataFrame) {

package/src/tests/monomer-libraries-tests.ts

@@ -53,14 +53,18 @@ category('monomerLibraries', () => {
     const libSettings = await getUserLibSettings();
     const libFileEventManager = MonomerLibFileEventManager.getInstance();
     const libFileManager = await MonomerLibFileManager.getInstance(libFileEventManager);
-    const libFnList = libFileManager.getValidLibraryPaths();
+
+    let libFnList = libFileManager.getValidLibraryPaths();
+    if (libFnList.length === 0)
+      libFnList = await libFileManager.getValidLibraryPathsAsynchronously();
+
     libSettings.exclude = libFnList;
     libSettings.explicit = [];
     await setUserLibSettings(libSettings);
 
     await monomerLibHelper.loadLibraries(true);
     const currentMonomerLib = monomerLibHelper.getBioLib();
-    expect(currentMonomerLib.getPolymerTypes().length === 0, true);
-    const monomerOfTypesList = currentMonomerLib.getMonomerMolsByPolymerType('PEPTIDE');
-  }, {skipReason: '#2690'});
+    const polymerTypes = currentMonomerLib.getPolymerTypes();
+    expect(polymerTypes.length === 0, true);
+  });
 });

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

@@ -56,9 +56,14 @@ export class MonomerLibManager implements IMonomerLibHelper {
           getLibFileNameList(),
           getUserLibSettings(),
         ]);
-        const filteredLibFnList = libFileNameList
-          .filter((libFileName) => !settings.exclude.includes(libFileName))
-          .filter((libFileName) => settings.explicit.length > 0 ? settings.explicit.includes(libFileName) : true);
+
+        const filteredLibFnList = libFileNameList.filter((libFileName) => {
+          const isFileIncluded = !settings.exclude.includes(libFileName);
+          const isExplicit = settings.explicit.length === 0 || settings.explicit.includes(libFileName);
+
+          return isFileIncluded && isExplicit;
+        });
+
         const libs: IMonomerLib[] = await Promise.all(filteredLibFnList
           .map((libFileName) => {
             //TODO handle whether files are in place

package/src/utils/monomer-lib/library-file-manager/custom-monomer-lib-handlers.ts

@@ -4,7 +4,6 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {createJsonMonomerLibFromSdf} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
-import {PolyToolMonomerLibHandler} from '../../poly-tool/monomer-lib-handler';
 
 interface CustomMonomerLibHandler {
   getHelmLibContent(): Promise<string>;
@@ -40,41 +39,3 @@ export class SdfMonomerLibHandler implements CustomMonomerLibHandler {
       throw new Error(`File ${this.fileName} is not an SDF file`);
   }
 }
-
-
-/** Handler of custom monomer libs for PolyTool  */
-export class PolyToolCsvLibHandler implements CustomMonomerLibHandler {
-  constructor(private fileName: string, private fileContent: string) {
-    this.validateFileType();
-    const df = DG.DataFrame.fromCsv(this.fileContent);
-    const json = this.toJson(df);
-    this.polyToolMonomerLib = new PolyToolMonomerLibHandler(json);
-    this.validateContent();
-  }
-
-  private polyToolMonomerLib: PolyToolMonomerLibHandler;
-
-  async getHelmLibContent(): Promise<string> {
-    const rawLibData = this.polyToolMonomerLib.getJsonMonomerLib();
-    return JSON.stringify(rawLibData);
-  }
-
-  private toJson(df: DG.DataFrame): any[] {
-    return Array.from({length: df.rowCount}, (_, idx) =>
-      df.columns.names().reduce((entry: { [key: string]: any }, colName) => {
-        entry[colName] = df.get(colName, idx);
-        return entry;
-      }, {})
-    );
-  }
-
-  private validateFileType(): void {
-    if (!this.fileName.endsWith('.csv'))
-      throw new Error(`File ${this.fileName} is not an CSV file`);
-  }
-
-  private validateContent(): void {
-    if (!this.polyToolMonomerLib.isValid())
-      throw new Error('Invalid format of CSV monomer lib');
-  }
-}

package/src/utils/monomer-lib/library-file-manager/event-manager.ts

@@ -1,5 +1,5 @@
 import * as rxjs from 'rxjs';
-import {debounceTime, tap} from 'rxjs/operators';
+import {debounceTime, tap, skip} from 'rxjs/operators';
 
 export class MonomerLibFileEventManager {
   // WARNING: this must be a singleton because it manages the unique state
@@ -22,6 +22,18 @@ export class MonomerLibFileEventManager {
     return this._libraryFilesUpdateSubject$.getValue();
   }
 
+  // TODO: remove after adding init from user data storage
+  // WARNING: a temporary solution
+  async getValidLibraryPathsAsynchronously(): Promise<string[]> {
+    return new Promise((resolve) => {
+      this._libraryFilesUpdateSubject$.pipe(
+        skip(1)
+      ).subscribe((fileNames) => {
+        resolve(fileNames);
+      });
+    });
+  }
+
   changeValidFilesPathList(newList: string[]): void {
     this._libraryFilesUpdateSubject$.next(newList);
   }

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

@@ -28,20 +28,22 @@ export class MonomerLibFileManager {
     });
   }
 
-  private static instance: MonomerLibFileManager | undefined;
+  private static instancePromise: Promise<MonomerLibFileManager> | undefined;
 
   static async getInstance(
     libraryEventManager: MonomerLibFileEventManager,
   ): Promise<MonomerLibFileManager> {
-    if (MonomerLibFileManager.instance === undefined) {
-      const helmSchemaRaw = await grok.dapi.files.readAsText(HELM_JSON_SCHEMA_PATH);
-      const helmSchema = JSON.parse(helmSchemaRaw) as JSONSchemaType<any>;
-
-      const fileValidator = new MonomerLibFileValidator(helmSchema);
-      MonomerLibFileManager.instance = new MonomerLibFileManager(fileValidator, libraryEventManager);
+    if (!MonomerLibFileManager.instancePromise) {
+      MonomerLibFileManager.instancePromise = (async () => {
+        const helmSchemaRaw = await grok.dapi.files.readAsText(HELM_JSON_SCHEMA_PATH);
+        const helmSchema = JSON.parse(helmSchemaRaw) as JSONSchemaType<any>;
+
+        const fileValidator = new MonomerLibFileValidator(helmSchema);
+        return new MonomerLibFileManager(fileValidator, libraryEventManager);
+      })();
     }
 
-    return MonomerLibFileManager.instance;
+    return MonomerLibFileManager.instancePromise;
   }
 
   /** Add standard .json monomer library  */
@@ -103,6 +105,13 @@ export class MonomerLibFileManager {
     return this.libraryEventManager.getValidFilesPathList();
   }
 
+  // TODO: remove after adding init from user data storage
+  // WARNING: a temporary solution
+  async getValidLibraryPathsAsynchronously(): Promise<string[]> {
+    return await this.libraryEventManager.getValidLibraryPathsAsynchronously();
+  }
+
+
   private async libraryFileExists(fileName: string): Promise<boolean> {
     return await grok.dapi.files.exists(LIB_PATH + `${fileName}`);
   }
@@ -142,7 +151,7 @@ export class MonomerLibFileManager {
       `, consider fixing or removing them: ${invalidFiles.join(', ')}`;
 
       console.warn(message);
-      grok.shell.warning(message);
+      // grok.shell.warning(message);
     }
   }
 

package/src/utils/monomer-lib/library-file-manager/file-validator.ts

@@ -41,7 +41,7 @@ export class MonomerLibFileValidator {
       isValid = this.validateMonomerSchema(monomer);
       if (!isValid) {
         console.warn(
-          `Bio: Monomer Library File Validator:\nfile${fileName}\n monomer violating JSON schema:`,
+          `Bio: Monomer Library File Validator:\nfile ${fileName}\n monomer violating JSON schema:`,
           monomer,
           '\nError reason: ',
           this.validateMonomerSchema.errors,

package/src/utils/monomer-lib/library-file-manager/ui.ts

@@ -208,7 +208,12 @@ class DialogWrapper {
   private async getDialog(): Promise<DG.Dialog> {
     const eventManager = MonomerLibFileEventManager.getInstance();
     const widget = await MonomerLibraryManagerWidget.getContent(eventManager);
-    const dialog = ui.dialog('Manage monomer libraries');
+    const dialog = ui.dialog(
+      {
+        title: 'Manage monomer libraries',
+        helpUrl: '/help/datagrok/solutions/domains/bio/bio.md#manage-monomer-libraries'
+      }
+    );
     $(dialog.root).css('width', '350px');
     dialog.clear();
     dialog.addButton(

package/src/utils/poly-tool/csv-to-json-monomer-lib-converter.ts

@@ -0,0 +1,40 @@
+import * as DG from 'datagrok-api/dg';
+
+import {PolyToolMonomerLibHandler} from './monomer-lib-handler';
+
+/** Handler of custom monomer libs for PolyTool  */
+export class PolyToolCsvLibHandler {
+  constructor(private fileName: string, private fileContent: string) {
+    this.validateFileType();
+    const df = DG.DataFrame.fromCsv(this.fileContent);
+    const json = this.toJson(df);
+    this.polyToolMonomerLib = new PolyToolMonomerLibHandler(json);
+    this.validateContent();
+  }
+
+  private polyToolMonomerLib: PolyToolMonomerLibHandler;
+
+  async getJson(): Promise<any> {
+    const rawLibData = this.polyToolMonomerLib.getJsonMonomerLib();
+    return rawLibData;
+  }
+
+  private toJson(df: DG.DataFrame): any[] {
+    return Array.from({length: df.rowCount}, (_, idx) =>
+      df.columns.names().reduce((entry: { [key: string]: any }, colName) => {
+        entry[colName] = df.get(colName, idx);
+        return entry;
+      }, {})
+    );
+  }
+
+  private validateFileType(): void {
+    if (!this.fileName.endsWith('.csv'))
+      throw new Error(`File ${this.fileName} is not an CSV file`);
+  }
+
+  private validateContent(): void {
+    if (!this.polyToolMonomerLib.isValid())
+      throw new Error('Invalid format of CSV monomer lib');
+  }
+}

package/src/utils/poly-tool/transformation.ts

@@ -5,165 +5,219 @@ import * as DG from 'datagrok-api/dg';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {_package} from '../../package';
-import {addCommonTags} from './utils';
-import {HELM_WRAPPER, ALL_MONOMERS, CYCLIZATION_TYPE} from './const';
-import {MetaData, ConnectionData} from './types';
+import {HELM_WRAPPER} from './const';
 import {getMolColumnFromHelm} from '../helm-to-molfile';
+import {ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
-abstract class TransformationBase {
-  constructor(helmColumn: DG.Column<string>, meta: MetaData) {
-    this.helmColumn = helmColumn;
-    this.leftTerminal = meta.leftTerminal;
-    this.rightTerminal = meta.rightTerminal;
-  }
-
-  protected helmColumn: DG.Column<string>;
-  protected leftTerminal?: string;
-  protected rightTerminal?: string;
-
-  protected abstract hasTerminals(helm: string): boolean;
-  protected abstract getTransformedHelm(helm: string): string;
-  protected abstract getLinkedPositions(helm: string): [number, number];
-
-  transform(): string[] {
-    const resultList = this.helmColumn.toList().map((helm: string) => {
-      if (this.hasTerminals(helm))
-        return this.getTransformedHelm(helm);
-      return helm;
-    });
-    return resultList;
-  }
+type ConnectionData = {
+  allPos1: number[],
+  allPos2: number[],
+  allAttaches1: number[],
+  allAttaches2: number[],
 }
 
-class TransformationNCys extends TransformationBase {
-  constructor(helmColumn: DG.Column<string>, meta: MetaData) {
-    super(helmColumn, meta);
-  }
-
-  protected hasTerminals(helm: string): boolean {
-    // if (! helm.includes(this.rightTerminal + HELM_WRAPPER.RIGHT))
-    //   return false;
-    // if (this.leftTerminal === ALL_MONOMERS)
-    //   return true;
-    // return helm.includes(HELM_WRAPPER.LEFT + this.leftTerminal);
-    const positions = this.getLinkedPositions(helm);
-    return positions.every((el) => el > 0);
-  }
-
-  protected getLinkedPositions(helm: string): [number, number] {
-    const seq = helm.replace(HELM_WRAPPER.LEFT, '').replace(HELM_WRAPPER.RIGHT, '');
-    const monomers = seq.split('.');
-    const start = 0;
-    const end = monomers.findIndex((el, idx) => el === this.rightTerminal && idx > start);
-    return [start + 1, end + 1];
-  }
-
-  protected getTransformedHelm(helm: string): string {
-    const positions = this.getLinkedPositions(helm);
-    const source = {monomerPosition: positions[0], attachmentPoint: 1};
-    const target = {monomerPosition: positions[1], attachmentPoint: 3};
-    return getHelmCycle(helm, source, target);
-  }
+type Rule = {
+  firstMonomer: string,
+  secondMonomer: string,
+  firstModification: string,
+  secondModification: string,
+  firstR: number,
+  secondR: number
 }
 
-class TransformationNO extends TransformationBase {
-  constructor(helmColumn: DG.Column<string>, meta: MetaData) {
-    super(helmColumn, meta);
-  }
-
-  protected hasTerminals(helm: string): boolean {
-    if (this.leftTerminal === ALL_MONOMERS || this.rightTerminal === ALL_MONOMERS)
-      return true;
-    return helm.includes(HELM_WRAPPER.LEFT + this.leftTerminal) &&
-      helm.includes(this.rightTerminal + HELM_WRAPPER.RIGHT);
-  }
-
-  protected getLinkedPositions(helm: string): [number, number] {
-    return [1, getNumberOfMonomers(helm)];
-  }
-
-  protected getTransformedHelm(helm: string): string {
-    const positions = this.getLinkedPositions(helm);
-    const source = {monomerPosition: positions[0], attachmentPoint: 1};
-    const target = {monomerPosition: positions[1], attachmentPoint: 2};
-    return getHelmCycle(helm, source, target);
-  }
+function addCommonTags(col: DG.Column):void {
+  col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
+  col.setTag('aligned', ALIGNMENT.SEQ);
+  col.setTag('alphabet', ALPHABET.PT);
 }
 
-class TransformationR3 extends TransformationBase {
-  constructor(helmColumn: DG.Column<string>, meta: MetaData) {
-    super(helmColumn, meta);
+class TransformationCommon {
+  helmColumn: DG.Column;
+
+  constructor(helmColumn: DG.Column<string>) {
+    this.helmColumn = helmColumn;
   }
 
   protected hasTerminals(helm: string): boolean {
-    if (this.leftTerminal === ALL_MONOMERS || this.rightTerminal === ALL_MONOMERS)
-      return true;
-    const positions = this.getLinkedPositions(helm);
-    return positions.every((el) => el > 0);
+    let isLinkable = false;
+    if (helm.includes('(1)'))
+      isLinkable = true;
+    if (helm.includes('(2)'))
+      isLinkable = true;
+
+    return isLinkable;
   }
 
-  protected getLinkedPositions(helm: string): [number, number] {
+  protected getLinkedPositions(helm: string, ruleCount: number): [number, number][] {
     const seq = helm.replace(HELM_WRAPPER.LEFT, '').replace(HELM_WRAPPER.RIGHT, '');
     const monomers = seq.split('.');
-    const start = monomers.findIndex((el) => el === this.leftTerminal);
-    const end = monomers.findIndex((el, idx) => el === this.rightTerminal && idx > start);
-    return [start + 1, end + 1];
-  }
+    const result:[number, number][] = new Array<[number, number]>(ruleCount);
+
+    for (let i = 0; i < ruleCount; i++) {
+      let firstFound = false;
+      for (let j = 0; j < monomers.length; j++) {
+        if (monomers[j].includes(`(${i + 1})`)) {
+          if (firstFound) {
+            result[i][1] = j;
+            break;
+          } else {
+            firstFound = true;
+            result[i] = [j, 0];
+          }
+        }
+      }
+
+      if (!firstFound)
+        result[i] = [-1, -1];
+    }
+
+
+    return result;
+  }
+
+  protected getRules(rulesTable: DG.DataFrame): Rule[] {
+    const ruleCount = rulesTable.rowCount;
+    const rules: Rule[] = new Array<Rule>(ruleCount);
+    const codeCol = rulesTable.columns.byName('code');
+    const monomer1Col = rulesTable.columns.byName('monomer1');
+    const monomer2Col = rulesTable.columns.byName('monomer2');
+    const modification1Col = rulesTable.columns.byName('modification1');
+    const modification2Col = rulesTable.columns.byName('modification2');
+    const r1Col = rulesTable.columns.byName('R1');
+    const r2Col = rulesTable.columns.byName('R2');
+
+    for (let i = 0; i < ruleCount; i++) {
+      rules[i] = {
+        firstMonomer: monomer1Col.get(i),
+        secondMonomer: monomer2Col.get(i),
+        firstModification: modification1Col.get(i),
+        secondModification: modification2Col.get(i),
+        firstR: r1Col.get(i),
+        secondR: r2Col.get(i),
+      };
+    }
+
+    return rules;
+  }
+
+  protected getTransformedHelm(helm: string, rules: Rule[]): string {
+    const ruleCount = rules.length;
+    const positions = this.getLinkedPositions(helm, ruleCount);
+
+    const allPos1: number [] = [];
+    const allPos2: number [] = [];
+    const allAttaches1: number [] = [];
+    const allAttaches2: number [] = [];
+
+    for (let i = 0; i < ruleCount; i++) {
+      if (positions[i][0] == -1)
+        continue;
+
+      helm = helm.replaceAll(`(${i + 1})`, '');
+      const seq = helm.replace(HELM_WRAPPER.LEFT, '').replace(HELM_WRAPPER.RIGHT, '');
+      const monomers = seq.split('.');
+      const firstMonomer = monomers[positions[i][0]].replace('[', '').replace(']', '');
+      const secondMonomer = monomers[positions[i][1]].replace('[', '').replace(']', '');
+      let attach1 = 0;
+      let attach2 = 0;
+      if (firstMonomer === rules[i].firstMonomer && secondMonomer === rules[i].secondMonomer) {
+        monomers[positions[i][0]] = monomers[positions[i][0]].replace(firstMonomer, rules[i].firstModification);
+        monomers[positions[i][1]] = monomers[positions[i][1]].replace(secondMonomer, rules[i].secondModification);
+        attach1 = rules[i].firstR;
+        attach2 = rules[i].secondR;
+      } else if (secondMonomer === rules[i].firstModification && firstMonomer === rules[i].secondModification) {
+        monomers[positions[i][0]] = monomers[positions[i][1]].replace(secondMonomer, rules[i].secondModification);
+        monomers[positions[i][1]] = rules[i].firstModification.replace(firstMonomer, rules[i].firstModification);
+        attach1 = rules[i].secondR;
+        attach2 = rules[i].firstR;
+      } else {
+        continue;
+      }
+
+      allPos1.push(positions[i][0] + 1);
+      allPos2.push(positions[i][1] + 1);
+      allAttaches1.push(attach1);
+      allAttaches2.push(attach2);
+
+      helm = HELM_WRAPPER.LEFT;
+      for (let i = 0; i < monomers.length; i ++) {
+        if (i != monomers.length - 1)
+          helm = helm + monomers[i] + '.';
+        else
+          helm = helm + monomers[i];
+      }
+      helm = helm + HELM_WRAPPER.RIGHT;
+    }
+
+
+    const cycledHelm = getHelmCycle(helm, {allPos1, allPos2, allAttaches1, allAttaches2});
+
+    return cycledHelm;
+  }
+
+  transform(rulesTable: DG.DataFrame): string[] {
+    const rules = this.getRules(rulesTable);
+    const resultList = this.helmColumn.toList().map((helm: string) => {
+      if (this.hasTerminals(helm))
+        return this.getTransformedHelm(helm, rules);
 
-  protected getTransformedHelm(helm: string): string {
-    const positions = this.getLinkedPositions(helm);
-    const source = {monomerPosition: positions[0], attachmentPoint: 3};
-    const target = {monomerPosition: positions[1], attachmentPoint: 3};
-    return getHelmCycle(helm, source, target);
+      console.log(helm);
+      return helm;
+    });
+    return resultList;
   }
 }
 
 class PolymerTransformation {
   private constructor() {}
 
-  static getInstance(molColumn: DG.Column<string>, meta: MetaData): TransformationBase {
-    const cyclizationType = meta.cyclizationType;
-    return (cyclizationType === CYCLIZATION_TYPE.R3) ? new TransformationR3(molColumn, meta) :
-      (cyclizationType === CYCLIZATION_TYPE.NCys) ? new TransformationNCys(molColumn, meta) :
-        new TransformationNO(molColumn, meta);
+  static getInstance(molColumn: DG.Column<string>) {
+    return new TransformationCommon(molColumn);
   }
 }
 
-function getNumberOfMonomers(helm: string): number {
-  const seq = helm.replace(HELM_WRAPPER.LEFT, '').replace(HELM_WRAPPER.RIGHT, '');
-  return seq.split('.').length;
-}
-
-function getHelmCycle(helm: string, source: ConnectionData, target: ConnectionData): string {
-  return helm.replace(HELM_WRAPPER.RIGHT,
-    `}$PEPTIDE1,PEPTIDE1,${
-      source.monomerPosition
-    }:R${
-      source.attachmentPoint
-    }-${
-      target.monomerPosition
-    }:R${
-      target.attachmentPoint
-    }${'$'.repeat(6)}`
-  );
+function getHelmCycle(helm: string, source: ConnectionData): string {
+  let cycled = helm.replace(HELM_WRAPPER.RIGHT, '}$');
+
+  for (let i = 0; i < source.allPos1.length; i++) {
+    if (i == 0)
+      cycled += 'PEPTIDE1,PEPTIDE1,';
+    else
+      cycled += '|PEPTIDE1,PEPTIDE1,';
+    cycled += `${source.allPos1[i]}:R${source.allAttaches1[i]}-${source.allPos2[i]}:R${source.allAttaches2[i]}`;
+  }
+
+  cycled += '$$$';
+  return cycled;
+  // return helm.replace(HELM_WRAPPER.RIGHT,
+  //   `}$PEPTIDE1,PEPTIDE1,${
+  //     source.monomerPosition
+  //   }:R${
+  //     source.attachmentPoint
+  //   }-${
+  //     target.monomerPosition
+  //   }:R${
+  //     target.attachmentPoint
+  //   }${'$'.repeat(6)}`
+  // );
 }
 
 export async function addTransformedColumn(
-  molColumn: DG.Column<string>, meta: MetaData, addHelm: boolean
+  molColumn: DG.Column<string>, rulesTable: DG.DataFrame, addHelm: boolean
 ): Promise<void> {
   const df = molColumn.dataFrame;
   const uh = UnitsHandler.getOrCreate(molColumn);
   const sourceHelmCol = uh.convert(NOTATION.HELM);
-  const pt = PolymerTransformation.getInstance(sourceHelmCol, meta);
-  const targetList = pt.transform();
-  const helmColName = df.columns.getUnusedName(`${meta.transformationType}(` + molColumn.name + ')');
+  const pt = PolymerTransformation.getInstance(sourceHelmCol);
+  const targetList = pt.transform(rulesTable);
+  const helmColName = df.columns.getUnusedName('transformed(' + molColumn.name + ')');
   const targetHelmCol = DG.Column.fromList('string', helmColName, targetList);
 
   addCommonTags(targetHelmCol);
   targetHelmCol.setTag('units', NOTATION.HELM);
 
   const molCol = await getMolColumnFromHelm(df, targetHelmCol);
-  molCol.name = df.columns.getUnusedName(`${meta.transformationType}_molfile(` + molColumn.name + ')');
+  molCol.name = df.columns.getUnusedName('molfile(' + molColumn.name + ')');
 
   if (addHelm) {
     targetHelmCol.setTag('cell.renderer', 'helm');