@datagrok/sequence-translator 1.4.4 → 1.4.6

package/src/polytool/pt-dialog.ts

@@ -9,7 +9,10 @@ import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {MmcrTemps} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
+import {buildMonomerHoverLink} from '@datagrok-libraries/bio/src/monomer-works/monomer-hover';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
 import {getRules, RuleInputs, Rules, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
 import {doPolyToolConvert, getOverriddenLibrary} from './pt-conversion';
@@ -35,17 +38,18 @@ type PolyToolEnumerateChemSerialized = {
   screenLibrary: string | null;
 }
 
-export function polyToolEnumerateChemUI(cell?: DG.Cell): void {
-  getPolyToolEnumerationChemDialog(cell)
-    .then((dialog) => {
-      dialog.show({resizable: true});
-    })
-    .catch((_err: any) => {
-      grok.shell.warning('To run PolyTool Enumeration, sketch the molecule and specify the R group to vary');
-    });
+export async function polyToolEnumerateChemUI(cell?: DG.Cell): Promise<void> {
+  await _package.initPromise;
+  try {
+    const dialog = await getPolyToolEnumerationChemDialog(cell);
+    dialog.show({resizable: true});
+  } catch (_err: any) {
+    grok.shell.warning('To run PolyTool Enumeration, sketch the molecule and specify the R group to vary');
+  }
 }
 
 export async function polyToolConvertUI(): Promise<void> {
+  await _package.initPromise;
   let dialog: DG.Dialog;
   try {
     dialog = await getPolyToolConvertDialog();
@@ -74,7 +78,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;
       }
     });
@@ -231,6 +235,11 @@ async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dial
   }
 }
 
+function dealGroups(col: DG.Column<string>): void {
+  for (let i = 0; i < col.length; i++)
+    col.set(i, col.get(i)!.replaceAll('undefined', 'H'));
+}
+
 /** Returns Helm and molfile columns.  */
 export async function polyToolConvert(
   seqCol: DG.Column<string>, generateHelm: boolean, chiralityEngine: boolean, ruleFiles: string[]
@@ -241,11 +250,11 @@ export async function polyToolConvert(
       if (!df) return colName;
       return df.columns.getUnusedName(colName);
     };
-    await getHelmHelper(); // initializes JSDraw and org
+    const helmHelper = await getHelmHelper(); // initializes JSDraw and org
 
     const table = seqCol.dataFrame;
     const rules = await getRules(ruleFiles);
-    const resList = doPolyToolConvert(seqCol.toList(), rules);
+    const resList = doPolyToolConvert(seqCol.toList(), rules, helmHelper);
 
     const resHelmColName = getUnusedName(table, `transformed(${seqCol.name})`);
     const resHelmCol = DG.Column.fromType(DG.COLUMN_TYPE.STRING, resHelmColName, resList.length)
@@ -256,17 +265,24 @@ export async function polyToolConvert(
     if (generateHelm && table) table.columns.add(resHelmCol, true);
 
     const seqHelper: ISeqHelper = await getSeqHelper();
+    const rdKitModule: RDModule = await getRdKitModule();
     const lib = await getOverriddenLibrary(rules);
+    const resHelmColTemp = resHelmCol.temp;
+    resHelmColTemp[MmcrTemps.overriddenLibrary] = lib;
+    resHelmCol.temp = resHelmColTemp;
     const toAtomicLevelRes =
       await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, /* highlight */ generateHelm, lib);
     const resMolCol = toAtomicLevelRes.molCol!;
-
+    dealGroups(resMolCol);
     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

@@ -5,10 +5,8 @@ import * as DG from 'datagrok-api/dg';
 import $ from 'cash-dom';
 import wu from 'wu';
 import {fromEvent, Unsubscribable} from 'rxjs';
-
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {HelmAtom, HelmMol} from '@datagrok-libraries/helm-web-editor/src/types/org-helm';
-import {getHelmHelper, HelmInputBase} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {HelmAtom} from '@datagrok-libraries/helm-web-editor/src/types/org-helm';
+import {getHelmHelper, HelmInputBase, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {HelmType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
 import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
@@ -16,19 +14,18 @@ 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
-} from './types';
+import {PolyToolEnumeratorParams, PolyToolEnumeratorType, PolyToolEnumeratorTypes} from './types';
 import {getLibrariesList} from './utils';
 import {doPolyToolEnumerateHelm, PT_HELM_EXAMPLE} from './pt-enumeration-helm';
 import {PolyToolPlaceholdersInput} from './pt-placeholders-input';
 import {defaultErrorHandler} from '../utils/err-info';
 import {PolyToolPlaceholdersBreadthInput} from './pt-placeholders-breadth-input';
 import {PT_UI_DIALOG_ENUMERATION} from './const';
+import {PolyToolDataRole, PolyToolTags} from '../consts';
+import {Chain} from './pt-conversion';
 
-import {_package} from '../package';
+import {_package, applyNotationProviderForCyclized} from '../package';
 
 type PolyToolEnumerateInputs = {
   macromolecule: HelmInputBase;
@@ -36,8 +33,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,11 +44,14 @@ 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> {
+  await _package.initPromise;
+
   const maxWidth = window.innerWidth;
   const maxHeight = window.innerHeight;
 
@@ -117,7 +118,6 @@ export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
   }
 }
 
-
 async function getPolyToolEnumerateDialog(
   cell?: DG.Cell, resizeInputs?: () => void
 ): Promise<DG.Dialog> {
@@ -160,10 +160,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 +186,7 @@ async function getPolyToolEnumerateDialog(
         }),
     };
 
+    inputs.toHarmonizedSequence.root.style.display = 'none';
     inputs.trivialNameCol.addOptions(trivialNameSampleDiv);
 
     let placeholdersValidity: string | null = null;
@@ -308,11 +311,12 @@ async function getPolyToolEnumerateDialog(
     inputs.macromolecule.root.style.setProperty('min-width', '250px', 'important');
     // inputs.macromolecule.root.style.setProperty('max-height', '300px', 'important');
 
+    const phPosSet = new Set<number>(inputs.placeholders.placeholdersValue.map((ph) => ph.position));
     const updateMolView = () => {
       const mol = inputs.macromolecule.molValue;
       for (let aI = 0; aI < mol.atoms.length; aI++) {
         const a = mol.atoms[aI];
-        a.highlighted = aI in inputs.placeholders.placeholdersValue;
+        a.highlighted = phPosSet.has(aI);
       }
       inputs.macromolecule.redraw();
     };
@@ -359,22 +363,33 @@ async function getPolyToolEnumerateDialog(
       if (resizeInputs) resizeInputs();
     };
 
-    const fillForCurrentCell = async (cell?: DG.Cell): Promise<void> => {
+    const fillForCurrentCell = async (cell?: DG.Cell): Promise<PolyToolDataRole> => {
+      let resDataRole;
       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 mValue = await sh.getValue(cell.rowIndex);
+        helmValue = mValue.value;
         table = cell.dataFrame;
+        resDataRole = (mValue.tags[PolyToolTags.dataRole] as PolyToolDataRole.template) ?? PolyToolDataRole.macromolecule;
       } else {
         helmValue = PT_HELM_EXAMPLE;
+        resDataRole = PolyToolDataRole.macromolecule;
       }
-
       inputs.macromolecule.stringValue = helmValue;
+
+      if (resDataRole === PolyToolDataRole.template) {
+        inputs.toAtomicLevel.root.style.display = 'none';
+      } else {
+        inputs.toAtomicLevel.root.style.removeProperty('display');
+      }
+
       fillTrivialNameList(table);
+      return resDataRole;
     };
 
-    await fillForCurrentCell(cell);
+    let dataRole: PolyToolDataRole = await fillForCurrentCell(cell);
 
     const exec = async (): Promise<void> => {
       try {
@@ -397,10 +412,12 @@ async function getPolyToolEnumerateDialog(
           const params: PolyToolEnumeratorParams = {
             placeholders: inputs.placeholders.placeholdersValue,
             type: inputs.enumeratorType.value!,
-            placeholdersBreadth: inputs.placeholdersBreadth.placeholdersBreadthValue,
+            breadthPlaceholders: inputs.placeholdersBreadth.placeholdersBreadthValue,
             keepOriginal: inputs.keepOriginal.value,
           };
-          const enumeratorResDf = await polyToolEnumerateHelm(srcHelm, srcId, params, inputs.toAtomicLevel.value, seqHelper);
+          const toAtomicLevelV = inputs.toAtomicLevel.value && dataRole == PolyToolDataRole.macromolecule;
+          const enumeratorResDf = await polyToolEnumerateHelm(srcHelm, dataRole, srcId, params,
+            toAtomicLevelV, seqHelper, helmHelper);
           grok.shell.addTableView(enumeratorResDf);
         }
       } catch (err: any) {
@@ -414,8 +431,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 +450,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 +461,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) {
@@ -453,23 +472,49 @@ async function getPolyToolEnumerateDialog(
   }
 }
 
+/**
+ * @param {DG.SemanticValue} srcValue Source value to enumerate, either of data role
+ *                                    {@link PolyToolDataRole.template} or {@link PolyToolDataRole.macromolecule}
+ * */
 async function polyToolEnumerateHelm(
-  srcHelm: string, srcId: { value: string, colName: string } | null, params: PolyToolEnumeratorParams,
-  toAtomicLevel: boolean, seqHelper: ISeqHelper,
+  srcHelm: string, dataRole: PolyToolDataRole, srcId: { value: string, colName: string } | null,
+  params: PolyToolEnumeratorParams, toAtomicLevel: boolean, seqHelper: ISeqHelper, helmHelper: IHelmHelper
 ): Promise<DG.DataFrame> {
   const pi = DG.TaskBarProgressIndicator.create('PolyTool enumerating...');
   try {
     await getHelmHelper(); // initializes JSDraw and org
 
     const resList = doPolyToolEnumerateHelm(srcHelm, srcId?.value ?? '', params);
-    const enumHelmCol = DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Enumerated', resList.length)
-      .init((rowIdx: number) => resList[rowIdx][0]);
-    const enumeratorResDf = DG.DataFrame.fromColumns([enumHelmCol]);
+    let enumCol: DG.Column<string>;
+    switch (dataRole) {
+    case PolyToolDataRole.macromolecule: {
+      enumCol = DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Enumerated', resList.length)
+        .init((rowIdx: number) => resList[rowIdx][0]);
+      break;
+    }
+    case PolyToolDataRole.template: {
+      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);
+        templateList[rowIdx] = chain.getNotation();
+      }
+      enumCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'Enumerated', templateList);
+      // enumCol.semType = DG.SEMTYPE.MACROMOLECULE;
+      // enumCol.setTag(PolyToolTags.dataRole, PolyToolDataRole.template);
+      // applyNotationProviderForCyclized(enumCol, '-');
+      break;
+    }
+    }
+    const enumeratorResDf = DG.DataFrame.fromColumns([enumCol]);
+    await grok.data.detectSemanticTypes(enumeratorResDf);
+    if (dataRole == PolyToolDataRole.template) {
+      applyNotationProviderForCyclized(enumCol, '-');
+    }
 
-    if (toAtomicLevel) {
+    if (toAtomicLevel && dataRole != PolyToolDataRole.template) {
       const seqHelper: ISeqHelper = await getSeqHelper();
-      const toAtomicLevelRes = await seqHelper.helmToAtomicLevel(enumHelmCol, true, true);
-      toAtomicLevelRes.molCol!.semType = DG.SEMTYPE.MOLECULE;
+      const toAtomicLevelRes = await seqHelper.helmToAtomicLevel(enumCol, true, true);
       enumeratorResDf.columns.add(toAtomicLevelRes.molCol!, false);
     }
 

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

@@ -4,13 +4,14 @@ import * as DG from 'datagrok-api/dg';
 
 import {
   HelmType, HelmMol,
-  JSDraw2ModuleType, OrgType
+  JSDraw2ModuleType, OrgType,
+  IHelmEditorOptions
 } from '@datagrok-libraries/bio/src/helm/types';
 
 
 import {Chain} from './pt-conversion';
 import {getAvailableMonomers} from './utils';
-import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes, PolyToolPlaceholders, PolyToolPlaceholdersBreadth} 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]}$$$$';
@@ -43,14 +44,14 @@ function polyToolEnumeratorCore(m: HelmMol, start: number, end: number, monomerL
  * @param  placeholders Placeholders by zero-based position key
  * @returns {string[]} List of enumerated molecules in Helm format
  */
-function getPtEnumeratorSingle(m: HelmMol, placeholders: PolyToolPlaceholders): HelmMol[] {
+function getPtEnumeratorSingle(m: HelmMol, placeholders: PolyToolPlaceholder[]): HelmMol[] {
   const coreResList: HelmMol[][] = placeholders
     .map((ph) => polyToolEnumeratorCore(m, ph.position, ph.position, ph.monomers));
   const resMolList = coreResList.reduce((acc, posList) => acc.concat(posList), []);
   return resMolList;
 }
 
-function getPtEnumeratorMatrix(m: HelmMol, placeholders: PolyToolPlaceholders): HelmMol[] {
+function getPtEnumeratorMatrix(m: HelmMol, placeholders: PolyToolPlaceholder[]): HelmMol[] {
   let resMolList = [m];
   for (const ph of placeholders) {
     const phResMolList: HelmMol[][] = resMolList.map((m: HelmMol) => polyToolEnumeratorCore(m, ph.position, ph.position, ph.monomers));
@@ -59,7 +60,10 @@ function getPtEnumeratorMatrix(m: HelmMol, placeholders: PolyToolPlaceholders):
   return resMolList;
 }
 
-function getPtEnumeratorBreadth(m: HelmMol, placeholdersBreadth: PolyToolPlaceholdersBreadth): HelmMol[] {
+function getPtEnumeratorBreadth(m: HelmMol, placeholdersBreadth: PolyToolBreadthPlaceholder[]): HelmMol[] {
+  if (placeholdersBreadth.length == 0)
+    return [];
+
   let resMolList = [m];
   for (const phb of placeholdersBreadth) {
     const phResMolList: HelmMol[][] = resMolList.map((m: HelmMol) => polyToolEnumeratorCore(m, phb.start, phb.end, phb.monomers));
@@ -72,7 +76,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;
@@ -93,8 +97,8 @@ export function doPolyToolEnumerateHelm(
   }
 
   let resBreadthMolList: HelmMol[] = [];
-  if (params.placeholdersBreadth) {
-    resBreadthMolList = getPtEnumeratorBreadth(molHandler.m, params.placeholdersBreadth);
+  if (params.breadthPlaceholders) {
+    resBreadthMolList = getPtEnumeratorBreadth(molHandler.m, params.breadthPlaceholders);
   }
   resMolList = resMolList.concat(resBreadthMolList);
 

package/src/polytool/pt-placeholders-breadth-input.ts

@@ -3,7 +3,7 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
 import {Unsubscribable} from 'rxjs';
-import {PolyToolPlaceholders, PolyToolPlaceholdersBreadth} from './types';
+import {PolyToolBreadthPlaceholder} from './types';
 import {parseMonomerSymbolList} from './pt-placeholders-input';
 
 export class PolyToolPlaceholdersBreadthInput extends DG.JsInputBase<DG.DataFrame> {
@@ -21,7 +21,7 @@ export class PolyToolPlaceholdersBreadthInput extends DG.JsInputBase<DG.DataFram
 
   setStringValue(str: string): void { this.grid.dataFrame = DG.DataFrame.fromCsv(str); }
 
-  get placeholdersBreadthValue(): PolyToolPlaceholdersBreadth {
+  get placeholdersBreadthValue(): PolyToolBreadthPlaceholder[] {
     return dfToPlaceholdersBreadth(this.grid.dataFrame);
   }
 
@@ -97,8 +97,8 @@ export class PolyToolPlaceholdersBreadthInput extends DG.JsInputBase<DG.DataFram
   }
 }
 
-export function dfToPlaceholdersBreadth(df: DG.DataFrame): PolyToolPlaceholdersBreadth {
-  const res: PolyToolPlaceholdersBreadth = [];
+export function dfToPlaceholdersBreadth(df: DG.DataFrame): PolyToolBreadthPlaceholder[] {
+  const res: PolyToolBreadthPlaceholder[] = [];
   for (let rowI = 0; rowI < df.rowCount; rowI++) {
     const startPos = parseInt(df.get('Start', rowI)) - 1;
     const endPos = parseInt(df.get('End', rowI)) - 1;

package/src/polytool/pt-placeholders-input.ts

@@ -4,7 +4,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {Unsubscribable} from 'rxjs';
 
-import {PolyToolPlaceholders} from './types';
+import {PolyToolPlaceholder} from './types';
 
 export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
   get inputType(): string { return 'Positions'; }
@@ -21,7 +21,7 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
 
   setStringValue(str: string): void { this.grid.dataFrame = DG.DataFrame.fromCsv(str); }
 
-  get placeholdersValue(): PolyToolPlaceholders {
+  get placeholdersValue(): PolyToolPlaceholder[] {
     return dfToPlaceholders(this.grid.dataFrame);
   }
 
@@ -95,8 +95,8 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
   }
 }
 
-export function getPlaceholdersFromText(src: string): PolyToolPlaceholders {
-  const res: PolyToolPlaceholders = [];
+export function getPlaceholdersFromText(src: string): PolyToolPlaceholder[] {
+  const res: PolyToolPlaceholder[] = [];
   for (const line of src.split('\n')) {
     const lineM = /^\s*(?<pos>\d+)\s*:\s*(?<monomers>.+)$/.exec(line);
     if (lineM) {
@@ -108,8 +108,8 @@ export function getPlaceholdersFromText(src: string): PolyToolPlaceholders {
   return res;
 }
 
-export function dfToPlaceholders(df: DG.DataFrame): PolyToolPlaceholders {
-  const res: PolyToolPlaceholders = [];
+export function dfToPlaceholders(df: DG.DataFrame): PolyToolPlaceholder[] {
+  const res: PolyToolPlaceholder[] = [];
   for (let rowI = 0; rowI < df.rowCount; rowI++) {
     const pos = parseInt(df.get('Position', rowI)) - 1;
     if (!isNaN(pos)) {

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

@@ -4,15 +4,17 @@ 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';
+import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 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 +36,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;
       }
     });
@@ -87,9 +89,11 @@ export async function polyToolUnrule(
 ): Promise<DG.Column> {
   const pi = DG.TaskBarProgressIndicator.create('PolyTool unrule...');
   try {
+    const helmHelper = await getHelmHelper();
+
     const table = srcCol.dataFrame;
     const rules = await getRules(ruleFiles);
-    const resHelmList = doPolyToolUnrule(srcCol.toList(), rules);
+    const resHelmList = doPolyToolUnrule(srcCol.toList(), rules, helmHelper);
     const resHelmColName = `harmonized(srcCol.name)`;
     const resHelmCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, resHelmColName, resHelmList,);
     resHelmCol.semType = DG.SEMTYPE.MACROMOLECULE;

package/src/polytool/pt-unrule.ts

@@ -9,6 +9,7 @@ import {getPolyToolUnruleDialog} from './pt-unrule-dialog';
 import {Rules} from './pt-rules';
 
 import {_package} from '../package';
+import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 export async function polyToolUnruleUI(): Promise<void> {
   let dialog: DG.Dialog;
@@ -23,14 +24,14 @@ export async function polyToolUnruleUI(): Promise<void> {
 }
 
 /** Returns list of harmonized sequences. Covered with tests. */
-export function doPolyToolUnrule(helms: string[], rules: Rules): string[] {
+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])
       resHrzSeqList[i] = '';
     else {
-      const chain = Chain.fromHelm(helms[i]);
-      resHrzSeqList[i] = chain.getNotation(rules);
+      const chain = Chain.parseHelm(helms[i], helmHelper);
+      resHrzSeqList[i] = chain.getNotation();
     }
   }
   return resHrzSeqList;

package/src/polytool/types.ts

@@ -11,15 +11,15 @@ export enum PolyToolEnumeratorTypes {
 
 export type PolyToolEnumeratorType = typeof PolyToolEnumeratorTypes[keyof typeof PolyToolEnumeratorTypes];
 
-export type PolyToolPlaceholders = { position: number, monomers: string[] } [];
+export type PolyToolPlaceholder = { position: number, monomers: string[] };
 
-export type PolyToolPlaceholdersBreadth = { start: number, end: number, monomers: string[] }[];
+export type PolyToolBreadthPlaceholder = { start: number, end: number, monomers: string[] };
 
 export type PolyToolEnumeratorParams = {
   type: PolyToolEnumeratorType;
   /** position key is zero-based */
-  placeholders?: PolyToolPlaceholders;
-  placeholdersBreadth?: PolyToolPlaceholdersBreadth;
+  placeholders?: PolyToolPlaceholder[];
+  breadthPlaceholders?: PolyToolBreadthPlaceholder[];
   keepOriginal?: boolean;
   trivialName?: boolean;
 }