@datagrok/bio 2.15.13 → 2.16.0

package/src/tests/renderers-test.ts

@@ -5,12 +5,12 @@ import * as ui from 'datagrok-api/ui';
 import $ from 'cash-dom';
 import {fromEvent} from 'rxjs';
 
-import {category, expect, test, delay, testEvent} from '@datagrok-libraries/utils/src/test';
+import {category, expect, test, delay, testEvent, before} from '@datagrok-libraries/utils/src/test';
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
 import {generateLongSequence, generateManySequences} from '@datagrok-libraries/bio/src/utils/generator';
 
-import {importFasta} from '../package';
 import {convertDo} from '../utils/convert';
 import {performanceTest} from './utils/sequences-generators';
 import {multipleSequenceAlignmentUI} from '../utils/multiple-sequence-alignment-ui';
@@ -20,6 +20,12 @@ import * as C from '../utils/constants';
 import {_package} from '../package-test';
 
 category('renderers', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   test('long sequence performance ', async () => {
     await performanceTest(generateLongSequence, 'Long sequences');
   });
@@ -124,7 +130,7 @@ category('renderers', () => {
 
   async function _testAfterMsa() {
     const fastaTxt: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/FASTA.fasta');
-    const df: DG.DataFrame = importFasta(fastaTxt)[0];
+    const df = (await grok.functions.call('Bio:importFasta', {fileContent: fastaTxt}))[0] as DG.DataFrame;
 
     const srcSeqCol: DG.Column = df.getCol('sequence');
     const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: srcSeqCol});
@@ -148,7 +154,7 @@ category('renderers', () => {
     expect(srcSeqCol.getTag(bioTAGS.alphabet), ALPHABET.PT);
     expect(srcSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
-    const msaSeqCol = await multipleSequenceAlignmentUI({col: srcSeqCol});
+    const msaSeqCol = await multipleSequenceAlignmentUI({col: srcSeqCol}, seqHelper);
     await awaitGrid(tv.grid);
     expect(tv.grid.dataFrame.id, df.id);
 
@@ -159,7 +165,7 @@ category('renderers', () => {
     expect(msaSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
     // check newColumn with SeqHandler constructor
-    const _sh: SeqHandler = SeqHandler.forColumn(msaSeqCol);
+    const _sh: ISeqHandler = seqHelper.getSeqHandler(msaSeqCol);
   }
 
   async function _testAfterConvert() {
@@ -175,7 +181,7 @@ category('renderers', () => {
     // call to calculate 'cell.renderer' tag
     await grok.data.detectSemanticTypes(df);
 
-    const tgtCol: DG.Column = await convertDo(srcCol, NOTATION.SEPARATOR, '/');
+    const tgtCol: DG.Column = await convertDo(srcCol, seqHelper, NOTATION.SEPARATOR, '/');
     await awaitGrid(tv.grid);
     expect(tv.grid.dataFrame.id, df.id);
 
@@ -183,7 +189,7 @@ category('renderers', () => {
     expect(resCellRenderer, 'sequence');
 
     // check tgtCol with SeqHandler constructor
-    const _sh: SeqHandler = SeqHandler.forColumn(tgtCol);
+    const _sh: ISeqHandler = seqHelper.getSeqHandler(tgtCol);
   }
 
   async function _testAfterConvertToHelm() {
@@ -192,7 +198,7 @@ category('renderers', () => {
     await awaitGrid(view.grid);
 
     const srcCol = df.getCol('sequence');
-    const sh = SeqHandler.forColumn(srcCol);
+    const sh = seqHelper.getSeqHandler(srcCol);
     const tgtCol = sh.convert(NOTATION.HELM);
     df.columns.add(tgtCol);
     await awaitGrid(view.grid);

package/src/tests/scoring.ts

@@ -6,9 +6,8 @@ import wu from 'wu';
 
 import {category, test, expectFloat, before, after, expect} from '@datagrok-libraries/utils/src/test';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {IMonomerLibHelper, getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
-import {getMonomerLibHelper, sequenceIdentityScoring, sequenceSimilarityScoring} from '../package';
 import {
   getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
@@ -51,7 +50,8 @@ PEPTIDE1{[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[
   });
 
   test('Identity', async () => {
-    const scoresCol = await sequenceIdentityScoring(table, seqCol, reference);
+    const scoresCol = await grok.functions.call('Bio:sequenceIdentityScoring',
+      {table: table, macromolecule: seqCol, reference: reference}) as DG.Column<number>;
     for (let i = 0; i < scoresCol.length; i++) {
       const resScore = scoresCol.get(i)!;
       const tgtScore = table.get(expectedIdentity, i);
@@ -61,19 +61,22 @@ PEPTIDE1{[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[
   });
 
   test('Identity-shortReference', async () => {
-    const scoresCol = await sequenceIdentityScoring(table, seqCol, shortReference);
+    const scoresCol = await grok.functions.call('Bio:sequenceIdentityScoring',
+      {table: table, macromolecule: seqCol, reference: shortReference}) as DG.Column<number>;
     expect(wu.count(0).take(scoresCol.length).map((rowI) => scoresCol.get(rowI))
       .every((v) => v != null && !isNaN(v)), true);
   });
 
   test('Identity-longReference', async () => {
-    const scoresCol = await sequenceIdentityScoring(table, seqCol, longReference);
+    const scoresCol = await grok.functions.call('Bio:sequenceIdentityScoring',
+      {table: table, macromolecule: seqCol, reference: longReference}) as DG.Column<number>;
     expect(wu.count(0).take(scoresCol.length).map((rowI) => scoresCol.get(rowI))
       .every((v) => v != null && !isNaN(v)), true);
   });
 
   test('Similarity', async () => {
-    const scoresCol = await sequenceSimilarityScoring(table, seqCol, reference);
+    const scoresCol = await grok.functions.call('Bio:sequenceSimilarityScoring',
+      {table: table, macromolecule: seqCol, reference: reference}) as DG.Column<number>;
     for (let i = 0; i < scoresCol.length; i++) {
       const resScore = scoresCol.get(i)!;
       const tgtScore = table.get(expectedSimilarity, i);

package/src/tests/seq-handler-get-helm-tests.ts

@@ -3,17 +3,19 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {after, before, category, expect, test} from '@datagrok-libraries/utils/src/test';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
-import {NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
 category('SeqHandler: getHelm', () => {
+  let seqHelper: ISeqHelper;
   let monomerLibHelper: IMonomerLibHelper;
   let userLibSettings: UserLibSettings; // backup
 
   before(async () => {
+    seqHelper = await getSeqHelper();
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
 
@@ -26,7 +28,6 @@ category('SeqHandler: getHelm', () => {
     await monomerLibHelper.loadMonomerLib(true); // load user settings libraries
   });
 
-
   const tests: {
     [testName: string]: {
       src: {
@@ -79,8 +80,9 @@ category('SeqHandler: getHelm', () => {
     // if (srcSeparator) seqCol.setTag(TAGS.separator, srcSeparator);
     await grok.data.detectSemanticTypes(df);
 
-    const sh = SeqHandler.forColumn(seqCol);
-    const resHelm = await sh.getHelm(0, false);
+    const sh = seqHelper.getSeqHandler(seqCol);
+    const resSemValue = await sh.getHelm(0);
+    const resHelm = resSemValue.value;
     expect(resHelm, tgtHelm);
   }
 });

package/src/tests/seq-handler-get-region-tests.ts

@@ -1,11 +1,17 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {ALPHABET, NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 category('SeqHandler: getRegion', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   const data: {
     [testName: string]: {
       srcCsv: string,
@@ -76,7 +82,7 @@ PEPTIDE1{[Cys_SEt].T.*.*}$$$$`,
       const semType: string | null = await grok.functions.call('Bio:detectMacromolecule', {col: srcSeqCol});
       if (semType) srcSeqCol.semType = semType;
 
-      const srcSh = SeqHandler.forColumn(srcSeqCol);
+      const srcSh = seqHelper.getSeqHandler(srcSeqCol);
       const resSeqCol = srcSh.getRegion(testData.startIdx, testData.endIdx, 'regSeq');
 
       const tgtDf = DG.DataFrame.fromCsv(testData.tgtCsv);

package/src/tests/seq-handler-splitted-tests.ts

@@ -3,8 +3,8 @@ import * as DG from 'datagrok-api/dg';
 
 import wu from 'wu';
 
-import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {GapOriginals} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
@@ -16,7 +16,13 @@ enum Tests {
   helm = 'helm',
 }
 
-category('SeqHandler', () => {
+category('SeqHandler: splitted', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   const fG = GapOriginals[NOTATION.FASTA];
   const hG = GapOriginals[NOTATION.HELM];
   const sG = GapOriginals[NOTATION.SEPARATOR];
@@ -123,7 +129,7 @@ PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.T.dK.Thr_PO3H2}$$$$`
   };
 
   for (const [testName, testData] of Object.entries(data)) {
-    test(`splitted-${testName}`, async () => {
+    test(`${testName}`, async () => {
       const df: DG.DataFrame = DG.DataFrame.fromCsv(testData.src.csv);
       const col: DG.Column = df.getCol('seq');
 
@@ -131,7 +137,7 @@ PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.T.dK.Thr_PO3H2}$$$$`
       if (semType) col.semType = semType;
       expect(col.semType, DG.SEMTYPE.MACROMOLECULE);
 
-      const sh = SeqHandler.forColumn(col);
+      const sh = seqHelper.getSeqHandler(col);
       expect(sh.notation, testData.tgt.notation);
       expect(sh.separator === testData.tgt.separator, true);
 

package/src/tests/seq-handler-tests.ts

@@ -2,9 +2,10 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {category, test, expect} from '@datagrok-libraries/utils/src/test';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {category, test, expect, before} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
 
 const seqDna = `seq
 ACGTCACGTC
@@ -28,6 +29,12 @@ PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Thr_PO3H
 PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Thr_PO3H2.N.D-Orn.D-aThr.Phe_4Me}$$$$`;
 
 category('SeqHandler', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
   test('Seq-Fasta', async () => {
     const [_df, sh] = await loadCsvWithDetection(seqDna);
     expect(sh.notation, NOTATION.FASTA);
@@ -78,38 +85,38 @@ category('SeqHandler', () => {
     const seqCol = df.getCol('seq');
 
     // col.version will change because of changing .tags
-    const sh1 = SeqHandler.forColumn(seqCol);
+    const sh1 = seqHelper.getSeqHandler(seqCol);
 
     const v1 = seqCol.version;
     // col.version MUST NOT change and the same object returned
-    const sh2 = SeqHandler.forColumn(seqCol);
+    const sh2 = seqHelper.getSeqHandler(seqCol);
     const v2 = seqCol.version;
     expect(v1, v2, 'Unexpected column version changed');
     expect(sh1, sh2, 'Unexpected SeqHandler object changed');
 
     df.rows.addNew(['TACCCCTTCAAC']);
-    const sh3 = SeqHandler.forColumn(seqCol);
+    const sh3 = seqHelper.getSeqHandler(seqCol);
     const v3 = seqCol.version;
     expect(v2 < v3, true, 'Stalled column version on add row');
     expect(sh2 !== sh3, true, 'Stalled SeqHandler object on add row');
 
     seqCol.set(1, 'CAGTGTCCCCGT');
-    const sh4 = SeqHandler.forColumn(seqCol);
+    const sh4 = seqHelper.getSeqHandler(seqCol);
     const v4 = seqCol.version;
     expect(v3 < v4, true, 'Stalled column version on change data');
     expect(sh3 !== sh4, true, 'Stalled SeqHandler object on change data');
 
     seqCol.setTag('testTag', 'testValue');
-    const sh5 = SeqHandler.forColumn(seqCol);
+    const sh5 = seqHelper.getSeqHandler(seqCol);
     const v5 = seqCol.version;
     expect(v4 < v5, true, 'Stalled column version on set tag');
     expect(sh4 !== sh5, true, 'Stalled SeqHandler object on set tag');
   });
 
-  async function loadCsvWithDetection(csv: string): Promise<[df: DG.DataFrame, sh: SeqHandler]> {
+  async function loadCsvWithDetection(csv: string): Promise<[df: DG.DataFrame, sh: ISeqHandler]> {
     const df = DG.DataFrame.fromCsv(csv);
     await grok.data.detectSemanticTypes(df);
-    const sh = SeqHandler.forColumn(df.getCol('seq'));
+    const sh = seqHelper.getSeqHandler(df.getCol('seq'));
     return [df, sh];
   }
 
@@ -121,7 +128,7 @@ category('SeqHandler', () => {
   //   col.semType = DG.SEMTYPE.MACROMOLECULE;
   //   if (value === NOTATION.SEPARATOR)
   //     col.setTag(TAGS.separator, '-');
-  //   const sh = SeqHandler.forColumn(df.getCol('seq'));
+  //   const sh = seqHelper.getSeqHandler(df.getCol('seq'));
   //   return [df, sh];
   // }
 });

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

@@ -23,7 +23,6 @@ import {HelmBioFilter} from '../widgets/bio-substructure-filter-helm';
 
 import {_package} from '../package-test';
 
-
 category('bio-substructure-filters', async () => {
   let helmHelper: IHelmHelper;
   let monomerLibHelper: IMonomerLibHelper;
@@ -52,7 +51,7 @@ category('bio-substructure-filters', async () => {
     const fSubStr: string = 'MD';
     const fTrueCount: number = 3;
 
-    const filter = new BioSubstructureFilter();
+    const filter = await createBioSubstructureFilter();
     filter.attach(df);
     await filter.awaitRendered();
     try {
@@ -69,11 +68,11 @@ category('bio-substructure-filters', async () => {
       filter.detach();
     }
     await filter.awaitRendered();
-  });
+  }, {skipReason: 'GROK-16782'});
 
   test('separator', async () => {
     const msa = await readDataframe('tests/filter_MSA.csv');
-    const filter = new BioSubstructureFilter();
+    const filter = await createBioSubstructureFilter();
     await grok.data.detectSemanticTypes(msa);
     filter.attach(msa);
     await filter.awaitRendered();
@@ -102,7 +101,7 @@ category('bio-substructure-filters', async () => {
       filter.detach();
     }
     await filter.awaitRendered();
-  });
+  }, {skipReason: 'GROK-16782'});
 
   // test('helm', async () => {
   //   const df = await readDataframe('tests/filter_HELM.csv');
@@ -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 = await createBioSubstructureFilter();
     filter.attach(df);
     const dlg = ui.dialog('Test filters').add(filter.root).show(); // to waitForElementInDom
     await filter.awaitRendered();
@@ -188,7 +187,7 @@ category('bio-substructure-filters', async () => {
     }
     await filter.awaitRendered();
     await delay(3000); //TODO: await for grid.onLookChanged
-  });
+  }, {skipReason: 'GROK-16782'});
 
   // Generates unhandled exception accessing isFiltering before bioFilter created
   test('helm-view', async () => {
@@ -235,7 +234,7 @@ category('bio-substructure-filters', async () => {
       f2.detach();
     }
     await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
-  });
+  }, {skipReason: 'GROK-16782'});
 
   // MSA filter has the second input field for separator
   test('sync-msa', async () => {
@@ -269,7 +268,7 @@ category('bio-substructure-filters', async () => {
       f2.detach();
     }
     await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
-  });
+  }, {skipReason: 'GROK-16782'});
 
   test('sync-helm', async () => {
     const df = await _package.files.readCsv('tests/filter_HELM.csv');
@@ -312,7 +311,7 @@ category('bio-substructure-filters', async () => {
     await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
     await awaitGrid(view.grid);
     await delay(3000); //TODO: await for grid.onLookChanged
-  });
+  }, {skipReason: 'GROK-16782'});
 
   // two seq columns
 
@@ -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},
@@ -459,7 +457,7 @@ async function createFilter(colName: string, df: DG.DataFrame): Promise<BioSubst
       `Available in data frame are ${JSON.stringify(df.columns.names())}`);
   }
 
-  const filter = new BioSubstructureFilter();
+  const filter = await createBioSubstructureFilter();
   filter.attach(df);
   filter.applyState({columnName: colName});
   filter.column = df.col(colName);
@@ -467,3 +465,8 @@ async function createFilter(colName: string, df: DG.DataFrame): Promise<BioSubst
   //filter.tableName = df.name;
   return filter;
 };
+
+async function createBioSubstructureFilter(): Promise<BioSubstructureFilter> {
+  const filter = await grok.functions.call('Bio:bioSubstructureFilter');
+  return filter.dart.jsFilter as BioSubstructureFilter;
+}

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;
+}