@datagrok/bio 2.15.13 → 2.16.2

package/src/tests/sequence-space-utils.ts

@@ -1,13 +1,13 @@
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+
 import {expect} from '@datagrok-libraries/utils/src/test';
-import {sequenceSpaceTopMenu} from '../package';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {BYPASS_LARGE_DATA_WARNING} from '@datagrok-libraries/ml/src/functionEditors/consts';
 import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
 
 export async function _testSequenceSpaceReturnsResult(
-  df: DG.DataFrame, algorithm: DimReductionMethods, colName: string,
+  df: DG.DataFrame, algorithm: DimReductionMethods, colName: string
 ) {
   // await grok.data.detectSemanticTypes(df);
   const col: DG.Column = df.getCol(colName);
@@ -18,7 +18,12 @@ export async function _testSequenceSpaceReturnsResult(
   const preprocessingFunc = DG.Func.find({package: 'Bio', name: 'macromoleculePreprocessingFunction'})[0];
   if (!preprocessingFunc)
     throw new Error('Preprocessing function not found');
-  const sp = await sequenceSpaceTopMenu(df, df.col(colName)!, algorithm, MmDistanceFunctionsNames.LEVENSHTEIN, true,
-    preprocessingFunc, {[BYPASS_LARGE_DATA_WARNING]: true});
+  const sp = await grok.functions.call('Bio:sequenceSpaceTopMenu', {
+    table: df, molecules: df.col(colName)!,
+    methodName: algorithm, similarityMetric: MmDistanceFunctionsNames.LEVENSHTEIN,
+    plotEmbeddings: true, preprocessingFunction: preprocessingFunc, options: {[BYPASS_LARGE_DATA_WARNING]: true}
+  });
+  // const sp = await sequenceSpaceTopMenu(df, df.col(colName)!, algorithm, MmDistanceFunctionsNames.LEVENSHTEIN, true,
+  //   preprocessingFunc, {[BYPASS_LARGE_DATA_WARNING]: true});
   expect(sp != null, true);
 }

package/src/tests/splitters-test.ts

@@ -11,13 +11,12 @@ import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/type
 import {IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {splitToMonomersUI} from '../utils/split-to-monomers';
 import {awaitGrid} from './utils';
 import * as C from '../utils/constants';
-import {getHelmMonomers} from '../package';
 
-import {_package} from '../package-test';
 import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 
 category('splitters', async () => {
@@ -89,10 +88,12 @@ category('splitters', async () => {
 });
 
 category('splitters', () => {
+  let seqHelper: ISeqHelper;
   let monomerLibHelper: IMonomerLibHelper;
   let userLibSettings: UserLibSettings;
 
   before(async () => {
+    seqHelper = await getSeqHelper();
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
 
@@ -113,7 +114,7 @@ category('splitters', () => {
       seqCol.semType = semType;
     seqCol.setTag(bioTAGS.aligned, C.MSA);
 
-    const newDf = await splitToMonomersUI(df, seqCol);
+    const newDf: DG.DataFrame = await grok.functions.call('Bio:splitToMonomersTopMenu', {table: df, sequence: seqCol});
     expect(newDf.columns.names().includes('17'), true);
     // call to calculate 'cell.renderer' tag
     await grok.data.detectSemanticTypes(newDf);
@@ -134,7 +135,7 @@ PEPTIDE1{hHis.Aca.Cys_SEt}$$$,5.72388
     const expectedMonomerList = ['hHis', 'Aca', 'Cys_SEt', 'N', 'T'];
 
     const helmCol: DG.Column = df.getCol('HELM');
-    const res = getHelmMonomers(helmCol);
+    const res = await grok.functions.call('Bio:getHelmMonomers', {sequence: helmCol}) as string[];
 
     const missed = expectedMonomerList.filter((m) => !res.includes(m));
     const unexpected = res.filter((m) => !expectedMonomerList.includes(m));

package/src/tests/substructure-filters-tests.ts

@@ -11,7 +11,7 @@ import {
   getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
-import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {awaitGrid, readDataframe} from './utils';
 
@@ -23,15 +23,14 @@ import {HelmBioFilter} from '../widgets/bio-substructure-filter-helm';
 
 import {_package} from '../package-test';
 
-
 category('bio-substructure-filters', async () => {
-  let helmHelper: IHelmHelper;
+  let seqHelper: ISeqHelper;
   let monomerLibHelper: IMonomerLibHelper;
   /** Backup actual user's monomer libraries settings */
   let userLibSettings: UserLibSettings;
 
   before(async () => {
-    helmHelper = await getHelmHelper(); // init Helm package
+    seqHelper = await getSeqHelper();
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
 
@@ -52,7 +51,7 @@ category('bio-substructure-filters', async () => {
     const fSubStr: string = 'MD';
     const fTrueCount: number = 3;
 
-    const filter = new BioSubstructureFilter();
+    const filter = new BioSubstructureFilter(seqHelper, _package.logger);
     filter.attach(df);
     await filter.awaitRendered();
     try {
@@ -73,7 +72,7 @@ category('bio-substructure-filters', async () => {
 
   test('separator', async () => {
     const msa = await readDataframe('tests/filter_MSA.csv');
-    const filter = new BioSubstructureFilter();
+    const filter = new BioSubstructureFilter(seqHelper, _package.logger);
     await grok.data.detectSemanticTypes(msa);
     filter.attach(msa);
     await filter.awaitRendered();
@@ -112,7 +111,7 @@ category('bio-substructure-filters', async () => {
   //   // // Helm filter calls waitForElementInDom
   //   // const fg = view.getFiltersGroup({createDefaultFilters: false});
   //   // _package.logger.debug('Bio tests: substructureFilters/helm, filter attaching.');
-  //   // const filter = new BioSubstructureFilter();
+  //   // const filter = await createBioSubstructureFilter();
   //   // filter.attach(df);
   //   // _package.logger.debug('Bio tests: substructureFilters/helm, filter attached.');
   //   // const fg = await df.plot.fromType(DG.VIEWER.FILTERS, {
@@ -157,7 +156,7 @@ category('bio-substructure-filters', async () => {
     const view = grok.shell.addTableView(df);
 
     _package.logger.debug(`${logPrefix}, filter attaching.`);
-    const filter = new BioSubstructureFilter();
+    const filter = new BioSubstructureFilter(seqHelper, _package.logger);
     filter.attach(df);
     const dlg = ui.dialog('Test filters').add(filter.root).show(); // to waitForElementInDom
     await filter.awaitRendered();
@@ -337,7 +336,6 @@ category('bio-substructure-filters', async () => {
     const fSeq2SubStr: string = 'GCATT';
     const fSeq2Trues: number[] = df.getCol('trueSeq2').toList();
 
-    //const seq2Filter = new BioSubstructureFilter();
     const filterList: any[] = [
       {type: 'Bio:bioSubstructureFilter', columnName: fSeq1ColName},
       {type: 'Bio:bioSubstructureFilter', columnName: fSeq2ColName},
@@ -451,19 +449,20 @@ category('bio-substructure-filters', async () => {
     await delay(100);
     await awaitGrid(view.grid);
   });
+
+  async function createFilter(colName: string, df: DG.DataFrame): Promise<BioSubstructureFilter> {
+    if (!df.columns.names().includes(colName)) {
+      throw new Error(`The column '${colName}' not found. ` +
+        `Available in data frame are ${JSON.stringify(df.columns.names())}`);
+    }
+
+    const filter = new BioSubstructureFilter(seqHelper, _package.logger);
+    filter.attach(df);
+    filter.applyState({columnName: colName});
+    filter.column = df.col(colName);
+    filter.columnName = colName;
+    //filter.tableName = df.name;
+    return filter;
+  };
 });
 
-async function createFilter(colName: string, df: DG.DataFrame): Promise<BioSubstructureFilter> {
-  if (!df.columns.names().includes(colName)) {
-    throw new Error(`The column '${colName}' not found. ` +
-      `Available in data frame are ${JSON.stringify(df.columns.names())}`);
-  }
-
-  const filter = new BioSubstructureFilter();
-  filter.attach(df);
-  filter.applyState({columnName: colName});
-  filter.column = df.col(colName);
-  filter.columnName = colName;
-  //filter.tableName = df.name;
-  return filter;
-};

package/src/tests/to-atomic-level-tests.ts

@@ -15,7 +15,7 @@ import {
   getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 
 import {_package} from '../package-test';
@@ -60,11 +60,13 @@ category('toAtomicLevel', async () => {
   /** Backup actual user's monomer libraries settings */
   let userLibSettings: UserLibSettings;
 
+  let seqHelper: ISeqHelper;
   let monomerLib: IMonomerLib;
   let rdKitModule: RDModule;
 
   before(async () => {
     rdKitModule = await getRdKitModule();
+    seqHelper = await getSeqHelper();
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
     // Clear settings to test default
@@ -214,7 +216,7 @@ PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.Thr_PO3H2.Aca.Tyr
     seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
     seqCol.meta.units = NOTATION.FASTA;
     seqCol.setTag(bioTAGS.alphabet, ALPHABET.PT);
-    const sh = SeqHandler.forColumn(seqCol);
+    const sh = seqHelper.getSeqHandler(seqCol);
     const resCol = (await _testToAtomicLevel(srcDf, 'seq', monomerLibHelper))!;
     expect(polishMolfile(resCol.get(0)), polishMolfile(tgtMol));
   });
@@ -223,7 +225,7 @@ PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.Thr_PO3H2.Aca.Tyr
     df: DG.DataFrame, seqColName: string = 'seq', monomerLibHelper: IMonomerLibHelper
   ): Promise<DG.Column | null> {
     const seqCol: DG.Column<string> = df.getCol(seqColName);
-    const res = await _toAtomicLevel(df, seqCol, monomerLib, rdKitModule);
+    const res = await _toAtomicLevel(df, seqCol, monomerLib, seqHelper, rdKitModule);
     if (res.warnings.length > 0)
       _package.logger.warning(`_toAtomicLevel() warnings ${res.warnings.join('\n')}`);
     return res.molCol;

package/src/tests/to-atomic-level-ui-tests.ts

@@ -11,6 +11,7 @@ import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 type TestDataTargetType = { atomCount: number, bondCount: number };
 type TestDataType = {
@@ -22,10 +23,12 @@ category('toAtomicLevel-ui', () => {
 
   let monomerLibHelper: IMonomerLibHelper;
   let userLibSettings: UserLibSettings;
+  let seqHelper: ISeqHelper;
   let monomerLib: IMonomerLib;
   let rdKitModule: RDModule;
 
   before(async () => {
+    seqHelper = await getSeqHelper();
     rdKitModule = await getRdKitModule();
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
@@ -95,7 +98,7 @@ category('toAtomicLevel-ui', () => {
   async function _testToAtomicLevelFunc(
     seqCol: DG.Column<string>, nonlinear: boolean, tgt: TestDataTargetType,
   ): Promise<void> {
-    const res = (await sequenceToMolfile(seqCol.dataFrame, seqCol, nonlinear, false, monomerLib, rdKitModule))!;
+    const res = (await sequenceToMolfile(seqCol.dataFrame, seqCol, nonlinear, false, monomerLib, seqHelper, rdKitModule))!;
     expect(res.molCol!.semType, DG.SEMTYPE.MOLECULE);
     const resMolStr = res.molCol!.get(0)!;
     const resRdMol = rdKitModule.get_mol(resMolStr);

package/src/tests/utils/detectors-utils.ts

@@ -3,7 +3,7 @@ import * as grok from 'datagrok-api/grok';
 
 import {ALIGNMENT, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {expect} from '@datagrok-libraries/utils/src/test';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 export type DetectorTestData = { [testName: string]: { csv: string, neg?: string[], pos?: { [colName: string]: PosCol } } };
 
@@ -35,8 +35,8 @@ export async function _testNeg(readDf: DfReaderFunc, colName: string) {
 }
 
 export async function _testPos(
-  readDf: DfReaderFunc, colName: string, units: string, aligned: string | null,
-  alphabet: string | null, alphabetSize: number, alphabetIsMultichar?: boolean,
+  readDf: DfReaderFunc, colName: string, seqHelper: ISeqHelper,
+  units: string, aligned: string | null, alphabet: string | null, alphabetSize: number, alphabetIsMultichar?: boolean,
   separator: string | null = null,
 ) {
   const df: DG.DataFrame = await readDf();
@@ -53,7 +53,7 @@ export async function _testPos(
   if (separator)
     expect(col.getTag(bioTAGS.separator), separator);
 
-  const sh = SeqHandler.forColumn(col);
+  const sh = seqHelper.getSeqHandler(col);
   expect(sh.getAlphabetSize(), alphabetSize);
   expect(sh.getAlphabetIsMultichar(), alphabetIsMultichar);
   if (!sh.isHelm()) {

package/src/utils/calculate-scores.ts

@@ -1,13 +1,15 @@
 import * as DG from 'datagrok-api/dg';
-import { calculateScores, SCORE } from '@datagrok-libraries/bio/src/utils/macromolecule/scoring';
+
+import {calculateScores, SCORE} from '@datagrok-libraries/bio/src/utils/macromolecule/scoring';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 export async function calculateScoresWithEmptyValues(
-    table: DG.DataFrame, macromolecule: DG.Column, reference: string, scoring: SCORE
+  table: DG.DataFrame, macromolecule: DG.Column, reference: string, scoring: SCORE, seqHelper: ISeqHelper,
 ): Promise<DG.Column<number>> {
-    const scores = await calculateScores(table, macromolecule, reference, scoring);
-    for (let i = 0; i < scores.length; i++) {
-        if (macromolecule.isNone(i))
-            scores.set(i, null, false);
-    }
-    return scores;
-}
+  const scores = await calculateScores(table, macromolecule, reference, scoring, seqHelper);
+  for (let i = 0; i < scores.length; i++) {
+    if (macromolecule.isNone(i))
+      scores.set(i, null, false);
+  }
+  return scores;
+}

package/src/utils/cell-renderer-custom.ts

@@ -3,11 +3,14 @@ import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
 import {getGridCellColTemp, CellRendererBackBase} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {GridCell} from 'datagrok-api/dg';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+
+import {_package} from '../package';
 
 export class MacromoleculeCustomCellRenderer extends DG.GridCellRenderer {
+  private readonly seqHelper: ISeqHelper;
+
   get name(): string { return 'sequence'; }
 
   get cellType(): string { return 'sequence'; }
@@ -16,18 +19,26 @@ export class MacromoleculeCustomCellRenderer extends DG.GridCellRenderer {
 
   get defaultWidth(): number | null { return 230; }
 
-  getRendererBack(gridCell: DG.GridCell): CellRendererBackBase<string> {
-    const [gridCol, tableCol, temp] = getGridCellColTemp<string, any>(gridCell);
-    const sh = SeqHandler.forColumn(tableCol);
-    if (sh.notation !== NOTATION.CUSTOM)
-      throw new Error(`Unexpected notation: '${sh.notation}'.`);
-    const back = sh.getRendererBack(gridCol, tableCol);
+  constructor() {
+    super();
+    this.seqHelper = _package.seqHelper;
+  }
+
+  getRendererBack(gridCell: DG.GridCell): CellRendererBackBase<string> | null {
+    const [gridCol, tableCol, _temp] = getGridCellColTemp<string, any>(gridCell);
+    let back: CellRendererBackBase<string> | null = null;
+    if (this.seqHelper) {
+      const sh = this.seqHelper.getSeqHandler(tableCol);
+      if (sh.notation !== NOTATION.CUSTOM)
+        throw new Error(`Unexpected notation: '${sh.notation}'.`);
+      back = sh.getRendererBack(gridCol, tableCol);
+    }
     return back;
   }
 
-  override onMouseEnter(gridCell: GridCell, e: MouseEvent) {
+  override onMouseEnter(gridCell: DG.GridCell, e: MouseEvent) {
     const back = this.getRendererBack(gridCell);
-    back.onMouseEnter(gridCell, e);
+    back?.onMouseEnter(gridCell, e);
   }
 
   override onMouseLeave(gridCell: DG.GridCell, e: MouseEvent) {
@@ -39,32 +50,31 @@ export class MacromoleculeCustomCellRenderer extends DG.GridCellRenderer {
 
   override onMouseMove(gridCell: DG.GridCell, e: MouseEvent) {
     const back = this.getRendererBack(gridCell);
-    back.onMouseMove(gridCell, e);
+    back?.onMouseMove(gridCell, e);
   }
 
   override onClick(gridCell: DG.GridCell, e: MouseEvent) {
     const back = this.getRendererBack(gridCell);
-    back.onClick(gridCell, e);
+    back?.onClick(gridCell, e);
   }
 
   override onDoubleClick(gridCell: DG.GridCell, e: MouseEvent) {
     const back = this.getRendererBack(gridCell);
-    back.onDoubleClick(gridCell, e);
+    back?.onDoubleClick(gridCell, e);
   }
 
   override onKeyDown(gridCell: DG.GridCell, e: KeyboardEvent) {
     const back = this.getRendererBack(gridCell);
-    back.onKeyDown(gridCell, e);
+    back?.onKeyDown(gridCell, e);
   }
 
   override onKeyPress(gridCell: DG.GridCell, e: KeyboardEvent) {
     const back = this.getRendererBack(gridCell);
-    back.onKeyPress(gridCell, e);
+    back?.onKeyPress(gridCell, e);
   }
 
   override render(g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell, cellStyle: DG.GridCellStyle) {
     const back = this.getRendererBack(gridCell);
-    back.render(g, x, y, w, h, gridCell, cellStyle);
+    back?.render(g, x, y, w, h, gridCell, cellStyle);
   }
 }
-

package/src/utils/cell-renderer.ts

@@ -17,21 +17,19 @@ import {
   TAGS as bioTAGS,
   ALPHABET,
 } from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {getSplitter} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
-import {IMonomerLib, IMonomerLibBase} from '@datagrok-libraries/bio/src/types';
+import {IMonomerLibBase} from '@datagrok-libraries/bio/src/types';
 import {GapOriginals} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
-import {ISeqMonomer} from '@datagrok-libraries/bio/src/helm/types';
 import {execMonomerHoverLinks} from '@datagrok-libraries/bio/src/monomer-works/monomer-hover';
-import {CellRendererBackBase, getGridCellColTemp} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
+import {getGridCellColTemp} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
 import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
 import {MmcrTemps, rendererSettingsChangedState, tempTAGS} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
-import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+import {CellRendererWithMonomerLibBackBase} from './monomer-cell-renderer-base';
 import * as C from './constants';
 
 import {_package} from '../package';
-import {CellRendererWithMonomerLibBackBase} from './monomer-cell-renderer-base';
-import {timeout} from 'rxjs/operators';
 
 type TempType = { [tagName: string]: any };
 
@@ -60,6 +58,8 @@ type RendererGridCellTemp = {
 }
 
 export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
+  private readonly seqHelper: ISeqHelper;
+
   get name(): string { return 'sequence'; }
 
   get cellType(): string { return 'sequence'; }
@@ -68,6 +68,11 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
 
   get defaultWidth(): number | null { return 230; }
 
+  constructor() {
+    super();
+    this.seqHelper = _package.seqHelper;
+  }
+
   onClick(gridCell: DG.GridCell, _e: MouseEvent): void {
     const colTemp: TempType = gridCell.cell.column.temp;
     colTemp[tempTAGS.currentWord] = gridCell.cell.value;
@@ -106,7 +111,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
       getGridCellColTemp<string, MonomerPlacer>(gridCell);
     if (!tableCol) return;
     const tableColTemp: TempType = tableCol.temp;
-    const sh = SeqHandler.forColumn(tableCol);
+    const sh = this.seqHelper.getSeqHandler(tableCol);
 
     let gapLength = 0;
     const msaGapLength = 8;
@@ -132,6 +137,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
           };
         });
       tableCol.temp[MmcrTemps.rendererSettingsChanged] === rendererSettingsChangedState.true;
+      seqColTemp.init().then(() => {});
     }
 
     seqColTemp.render(g, x, y, w, h, gridCell, _cellStyle);

package/src/utils/check-input-column.ts

@@ -2,7 +2,9 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+
+import {_package} from '../package';
 
 /**
  * Checks if the column is suitable for the analysis.
@@ -13,9 +15,11 @@ import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
  * @param {boolean} notify show warning message if the column is not suitable for the analysis
  * @return {boolean} True if the column is suitable for the analysis.
  */
-export function checkInputColumnUI(col: DG.Column, name: string, allowedNotations: string[] = [],
-  allowedAlphabets: string[] = [], notify: boolean = true): boolean {
-  const [res, msg]: [boolean, string] = checkInputColumn(col, name, allowedNotations, allowedAlphabets);
+export function checkInputColumnUI(col: DG.Column, name: string,
+  allowedNotations: string[] = [], allowedAlphabets: string[] = [], notify: boolean = true
+): boolean {
+  const seqHelper = _package.seqHelper;
+  const [res, msg]: [boolean, string] = checkInputColumn(col, name, seqHelper, allowedNotations, allowedAlphabets);
   if (notify && !res)
     grok.shell.warning(msg);
   return res;
@@ -23,23 +27,23 @@ export function checkInputColumnUI(col: DG.Column, name: string, allowedNotation
 
 /**
  * Checks if the column is suitable for the analysis.
- * @param {DG.Column} col macromolecule coulumn.
- * @param {string} name column name
+ * @param {DG.Column} col macromolecule column.
+ * @param {string} name Analysis name
  * @param {string[]} allowedNotations allowed notations
  * @param {string[]} allowedAlphabets allowed alphabets
  * @return {[boolean, string]} [True if the column is suitable for the analysis, warning message].
  */
-export function checkInputColumn(
-  col: DG.Column, name: string, allowedNotations: string[] = [], allowedAlphabets: string[] = [],
+export function checkInputColumn(col: DG.Column, name: string, seqHelper: ISeqHelper,
+  allowedNotations: string[] = [], allowedAlphabets: string[] = [],
 ): [boolean, string] {
   let res: boolean = true;
   let msg: string = '';
 
-  const sh = SeqHandler.forColumn(col);
   if (col.semType !== DG.SEMTYPE.MACROMOLECULE) {
     grok.shell.warning(name + ' analysis is allowed for Macromolecules semantic type');
     res = false;
   } else {
+    const sh = seqHelper.getSeqHandler(col);
     const notation: string = sh.notation;
     if (allowedNotations.length > 0 &&
       !allowedNotations.some((n) => notation.toUpperCase() == (n.toUpperCase()))

package/src/utils/context-menu.ts

@@ -2,21 +2,21 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {_package} from '../package';
 
 
-export function addCopyMenuUI(cell: DG.Cell, menu: DG.Menu): void {
-  const sh = SeqHandler.forColumn(cell.column);
+export function addCopyMenuUI(cell: DG.Cell, menu: DG.Menu, seqHelper: ISeqHelper): void {
+  const sh = seqHelper.getSeqHandler(cell.column);
   const tgtNotationList: string[] = Object.values(NOTATION).filter((v) => v !== sh.units);
 
   menu.group('Copy')
     .items(tgtNotationList, (tgtNotation) => {
       const srcCol = cell.column;
       const srcRowIdx = cell.rowIndex;
-      const srcSh = SeqHandler.forColumn(srcCol);
+      const srcSh = seqHelper.getSeqHandler(srcCol);
       const separator = tgtNotation === NOTATION.SEPARATOR ? _package.properties.defaultSeparator : undefined;
       const joiner = srcSh.getJoiner({notation: tgtNotation as NOTATION, separator});
       const srcSS = srcSh.getSplitted(srcRowIdx);

package/src/utils/convert.ts

@@ -6,7 +6,7 @@ import $ from 'cash-dom';
 import {Subscription} from 'rxjs';
 
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 
 let convertDialog: DG.Dialog | null = null;
@@ -15,13 +15,14 @@ let convertDialogSubs: Subscription[] = [];
 /**
  * Converts notations of a Macromolecule column
  *
- * @param {DG.column} col Column with 'Macromolecule' semantic type
+ * @param {DG.Column<string>} col Column with 'Macromolecule' semantic type
+ * @param {ISeqHelper} seqHelper
  */
-export function convert(col?: DG.Column): void {
+export function convert(col: DG.Column<string> | undefined, seqHelper: ISeqHelper): void {
   let srcCol = col ?? grok.shell.t.columns.bySemType('Macromolecule')!;
   if (!srcCol)
     throw new Error('No column with Macromolecule semantic type found');
-  let converterSh = SeqHandler.forColumn(srcCol);
+  let converterSh = seqHelper.getSeqHandler(srcCol);
   let currentNotation: NOTATION = converterSh.notation;
   const dialogHeader = ui.divText(
     'Current notation: ' + currentNotation,
@@ -46,14 +47,16 @@ export function convert(col?: DG.Column): void {
     }
 
     srcCol = newCol;
-    converterSh = SeqHandler.forColumn(srcCol);
+    converterSh = seqHelper.getSeqHandler(srcCol);
     currentNotation = converterSh.notation;
     if (currentNotation === NOTATION.HELM)
       separatorInput.value = '/'; // helm monomers can have - in the name like D-aThr;
     dialogHeader.textContent = 'Current notation: ' + currentNotation;
     filteredNotations = notations.filter((e) => e !== currentNotation);
-    targetNotationInput = ui.input.choice('Convert to', {value: filteredNotations[0], items: filteredNotations,
-      onValueChanged: toggleSeparator});
+    targetNotationInput = ui.input.choice('Convert to', {
+      value: filteredNotations[0], items: filteredNotations,
+      onValueChanged: toggleSeparator
+    });
     toggleSeparator();
     convertDialog?.clear();
     convertDialog?.add(ui.div([
@@ -64,8 +67,10 @@ export function convert(col?: DG.Column): void {
     ]));
   };
 
-  const targetColumnInput = ui.input.column('Column', {table: grok.shell.t, value: srcCol,
-    onValueChanged: (value) => toggleColumn(value)});
+  const targetColumnInput = ui.input.column('Column', {
+    table: grok.shell.t, value: srcCol,
+    onValueChanged: (value) => toggleColumn(value)
+  });
 
   const separatorArray = ['-', '.', '/'];
   let filteredNotations = notations.filter((e) => e !== currentNotation);
@@ -79,8 +84,10 @@ export function convert(col?: DG.Column): void {
     else
       $(separatorInput.root).show();
   };
-  let targetNotationInput = ui.input.choice('Convert to', {value: filteredNotations[0], items: filteredNotations,
-    onValueChanged: toggleSeparator});
+  let targetNotationInput = ui.input.choice('Convert to', {
+    value: filteredNotations[0], items: filteredNotations,
+    onValueChanged: toggleSeparator
+  });
 
   // set correct visibility on init
   toggleSeparator();
@@ -101,7 +108,7 @@ export function convert(col?: DG.Column): void {
         const targetNotation = targetNotationInput.value as NOTATION;
         const separator: string | undefined = targetNotation === NOTATION.SEPARATOR ? separatorInput.value! : undefined;
 
-        await convertDo(srcCol, targetNotation, separator);
+        await convertDo(srcCol, seqHelper, targetNotation, separator);
       })
       .show({x: 350, y: 100});
 
@@ -118,8 +125,8 @@ export function convert(col?: DG.Column): void {
  * @param {NOTATION} targetNotation Target notation
  * @param {string | null} separator Separator for SEPARATOR notation
  */
-export async function convertDo(srcCol: DG.Column, targetNotation: NOTATION, separator?: string): Promise<DG.Column> {
-  const converterSh = SeqHandler.forColumn(srcCol);
+export async function convertDo(srcCol: DG.Column, seqHelper: ISeqHelper, targetNotation: NOTATION, separator?: string): Promise<DG.Column> {
+  const converterSh = seqHelper.getSeqHandler(srcCol);
   const newColumn = converterSh.convert(targetNotation, separator);
   srcCol.dataFrame.columns.add(newColumn);