@datagrok/bio 2.4.30 → 2.4.39

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

@@ -2,13 +2,11 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
+import {before, category, test, expect} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, getAlphabet, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {Column} from 'datagrok-api/dg';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 category('detectorsBenchmark', () => {
-
   let detectFunc: DG.Func;
 
   before(async () => {
@@ -23,38 +21,38 @@ category('detectorsBenchmark', () => {
   // -- fasta --
 
   test('fastaDnaShorts50Few50', async () => {
-      const et: number = await detectMacromoleculeBenchmark(10, NOTATION.FASTA, ALPHABET.DNA, 50, 50);
+      await detectMacromoleculeBenchmark(10, NOTATION.FASTA, ALPHABET.DNA, 50, 50);
     },
     {skipReason: '#1192'});
 
   test('fastaDnaShorts50Many1E6', async () => {
-      const et: number = await detectMacromoleculeBenchmark(10, NOTATION.FASTA, ALPHABET.DNA, 50, 1E6);
+      await detectMacromoleculeBenchmark(10, NOTATION.FASTA, ALPHABET.DNA, 50, 1E6);
     },
     {skipReason: '#1192'});
 
   test('fastaDnaLong1e6Few50', async () => {
-      const et: number = await detectMacromoleculeBenchmark(10, NOTATION.FASTA, ALPHABET.DNA, 1E6, 50);
+      await detectMacromoleculeBenchmark(10, NOTATION.FASTA, ALPHABET.DNA, 1E6, 50);
     },
     {skipReason: '#1192'});
 
   // -- separator --
 
   test('separatorDnaShorts50Few50', async () => {
-    const et: number = await detectMacromoleculeBenchmark(10, NOTATION.SEPARATOR, ALPHABET.DNA, 50, 50, '/');
+    detectMacromoleculeBenchmark(10, NOTATION.SEPARATOR, ALPHABET.DNA, 50, 50, '/');
   }, {skipReason: '#1192'});
 
   test('separatorDnaShorts50Many1E6', async () => {
-      const et: number = await detectMacromoleculeBenchmark(10, NOTATION.SEPARATOR, ALPHABET.DNA, 50, 1E6, '/');
+      detectMacromoleculeBenchmark(10, NOTATION.SEPARATOR, ALPHABET.DNA, 50, 1E6, '/');
     },
     { /* skipReason: 'slow transmit large dataset to detector' */});
 
   test('separatorDnaLong1e6Few50', async () => {
-      const et: number = await detectMacromoleculeBenchmark(10, NOTATION.SEPARATOR, ALPHABET.DNA, 1E6, 50, '/');
+      detectMacromoleculeBenchmark(10, NOTATION.SEPARATOR, ALPHABET.DNA, 1E6, 50, '/');
     },
     {skipReason: '#1192'});
 
   async function detectMacromoleculeBenchmark(
-    maxET: number, notation: NOTATION, alphabet: ALPHABET, length: number, count: number, separator?: string
+    maxET: number, notation: NOTATION, alphabet: ALPHABET, length: number, count: number, separator?: string,
   ): Promise<number> {
     return await benchmark<DG.FuncCall, DG.Column>(10,
       (): DG.FuncCall => {
@@ -70,48 +68,48 @@ category('detectorsBenchmark', () => {
           semType: DG.SEMTYPE.MACROMOLECULE,
           notation: notation,
           alphabet: alphabet,
-          separator: separator
+          separator: separator,
         });
       });
   }
 
   function generate(
-    notation: NOTATION, alphabet: string[], length: number, count: number, separator?: string
+    notation: NOTATION, alphabet: string[], length: number, count: number, separator?: string,
   ): DG.Column {
     let seqMerger: (seqMList: string[], separator?: string) => string;
 
     switch (notation) {
-    case NOTATION.FASTA:
-      seqMerger = (seqMList: string[]): string => {
-        let res: string = '';
-        for (let j = 0; j < seqMList.length; j++) {
-          const m = seqMList[j];
-          res += m.length == 1 ? m : `[${m}]`;
-        }
-        return res;
-      };
-      break;
-    case NOTATION.SEPARATOR:
-      seqMerger = (seqMList: string[], separator?: string): string => {
-        return seqMList.join(separator);
-      };
-      break;
-    default:
-      throw new Error(`Not supported notation '${notation}'.`);
+      case NOTATION.FASTA:
+        seqMerger = (seqMList: string[]): string => {
+          let res: string = '';
+          for (let j = 0; j < seqMList.length; j++) {
+            const m = seqMList[j];
+            res += m.length == 1 ? m : `[${m}]`;
+          }
+          return res;
+        };
+        break;
+      case NOTATION.SEPARATOR:
+        seqMerger = (seqMList: string[], separator?: string): string => {
+          return seqMList.join(separator);
+        };
+        break;
+      default:
+        throw new Error(`Not supported notation '${notation}'.`);
     }
 
     const buildSeq = (alphabet: string[], length: number): string => {
       const seqMList = new Array<string>(length);
-      for (let j = 0; j < length; j++) {
+      for (let j = 0; j < length; j++)
         seqMList[j] = alphabet[Math.floor(Math.random() * alphabet.length)];
-      }
+
       return seqMerger(seqMList, separator);
     };
 
     const seqList: string[] = Array(count);
-    for (let i = 0; i < count; i++) {
+    for (let i = 0; i < count; i++)
       seqList[i] = buildSeq(alphabet, length);
-    }
+
 
     return DG.Column.fromStrings('seq', seqList);
   }
@@ -123,13 +121,13 @@ category('detectorsBenchmark', () => {
     funcCall.callSync();
     const semType = funcCall.getOutputParamValue();
 
-    const col: DG.Column = funcCall.inputs.col;
+    const col: DG.Column = funcCall.inputs.col as unknown as DG.Column;
     if (semType) col.semType = semType;
     return col;
   }
 
   function checkDetectorRes(col: DG.Column, tgt: TgtType): void {
-    const uh = new UnitsHandler(col);
+    const uh = UnitsHandler.getOrCreate(col);
     expect(col.semType, tgt.semType);
     expect(uh.notation, tgt.notation);
     expect(uh.alphabet, tgt.alphabet);
@@ -138,9 +136,9 @@ category('detectorsBenchmark', () => {
 });
 
 
-/** Returns ET [ms] of test() */
+//Returns ET [ms] of test()
 async function benchmark<TData, TRes>(
-  maxET: number, prepare: () => TData, test: (data: TData) => Promise<TRes>, check: (res: TRes) => void
+  maxET: number, prepare: () => TData, test: (data: TData) => Promise<TRes>, check: (res: TRes) => void,
 ): Promise<number> {
   const data: TData = prepare();
 

package/src/tests/detectors-tests.ts

@@ -2,7 +2,7 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
+import {category, test, expect} from '@datagrok-libraries/utils/src/test';
 
 import {importFasta} from '../package';
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
@@ -67,69 +67,56 @@ category('detectors', () => {
     [csvTests.negSmiles]: string = `col1
 CCCCN1C(=O)CN=C(c2cc(F)ccc12)C3CCCCC3
 C1CCCCC1
-CCCCCC
-`;
+CCCCCC`;
     [csvTests.fastaDna1]: string = `seq
 ACGTC
 CAGTGT
-TTCAAC
-`;
+TTCAAC`;
     [csvTests.fastaRna1]: string = `seq
 ACGUC
 CAGUGU
-UUCAAC
-`;
+UUCAAC`;
     /** Pure amino acids sequence */
     [csvTests.fastaPt1]: string = `seq
 FWPHEY
 YNRQWYV
-MKPSEYV
-`;
+MKPSEYV`;
     [csvTests.fastaUn]: string = `seq
 [meI][hHis][Aca]NT[dE][Thr_PO3H2][Aca]D
 [meI][hHis][Aca][Cys_SEt]T[dK][Thr_PO3H2][Aca][Tyr_PO3H2]
-[Lys_Boc][hHis][Aca][Cys_SEt]T[dK][Thr_PO3H2][Aca][Tyr_PO3H2]
-`;
+[Lys_Boc][hHis][Aca][Cys_SEt]T[dK][Thr_PO3H2][Aca][Tyr_PO3H2]`;
     [csvTests.sepDna]: string = `seq
 A*C*G*T*C
 C*A*G*T*G*T
-T*T*C*A*A*C
-`;
+T*T*C*A*A*C`;
     [csvTests.sepRna]: string = `seq
 A*C*G*U*C
 C*A*G*U*G*U
-U*U*C*A*A*C
-`;
+U*U*C*A*A*C`;
     [csvTests.sepPt]: string = `seq
 F-W-P-H-E-Y
 Y-N-R-Q-W-Y-V
-M-K-P-S-E-Y-V
-`;
+M-K-P-S-E-Y-V`;
     [csvTests.sepUn1]: string = `seq
 abc-dfgg-abc1-cfr3-rty-wert
 rut12-her2-rty-wert-abc-abc1-dfgg
-rut12-rty-her2-abc-cfr3-wert-rut12
-`;
+rut12-rty-her2-abc-cfr3-wert-rut12`;
     [csvTests.sepUn2]: string = `seq
 abc/dfgg/abc1/cfr3/rty/wert
 rut12/her2/rty/wert//abc/abc1/dfgg
-rut12/rty/her2/abc/cfr3//wert/rut12
-`;
+rut12/rty/her2/abc/cfr3//wert/rut12`;
     [csvTests.sepMsaDna1]: string = `seq
 A-C--G-T--C-T
 C-A-C--T--G-T
-A-C-C-G-T-A-C-T
-`;
+A-C-C-G-T-A-C-T`;
     [csvTests.fastaMsaDna1]: string = `seq
 AC-GT-CT
 CAC-T-GT
-ACCGTACT
-`;
+ACCGTACT`;
     [csvTests.fastaMsaPt1]: string = `seq
 FWR-WYV-KHP
 YNR-WYV-KHP
-MWRSWY-CKHP
-`;
+MWRSWY-CKHP`;
   }();
 
   const enum Samples {
@@ -201,7 +188,7 @@ MWRSWY-CKHP
     return df;
   }
 
-  async function readFileFasta(file: string): Promise<DG.DataFrame> {
+  async function _readFileFasta(file: string): Promise<DG.DataFrame> {
     const txt: string = await grok.dapi.files.readAsText(file);
     const df: DG.DataFrame = importFasta(txt)[0];
     return df;
@@ -223,6 +210,8 @@ MWRSWY-CKHP
   test('Negative2', async () => { await _testNeg(readCsv(csvTests.neg2), 'col1'); });
   test('Negative3', async () => { await _testNeg(readCsv(csvTests.neg3), 'col1'); });
   test('NegativeSmiles', async () => { await _testNeg(readCsv(csvTests.negSmiles), 'col1'); });
+  test('NegativeStartEnd', async () => { await _testNegList(['START', 'END']); });
+  test('NegativeStartEndIntermediate', async () => { await _testNegList(['START', 'END', 'INTERMEDIATE']); });
 
   test('FastaDna1', async () => {
     await _testPos(readCsv(csvTests.fastaDna1), 'seq',
@@ -375,6 +364,15 @@ MWRSWY-CKHP
   });
 });
 
+export async function _testNegList(list: string[]): Promise<void> {
+  const col: DG.Column = DG.Column.fromList(DG.TYPE.STRING, 'col1', list);
+  const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: col});
+  if (col.semType === DG.SEMTYPE.MACROMOLECULE) {
+    const msg = `Negative test detected semType='${col.semType}', units='${col.getTag(DG.TAGS.UNITS)}'.`;
+    throw new Error(msg);
+  }
+}
+
 export async function _testNeg(readDf: DfReaderFunc, colName: string) {
   const df: DG.DataFrame = await readDf();
   const col: DG.Column = df.getCol(colName)!;
@@ -386,16 +384,13 @@ export async function _testNeg(readDf: DfReaderFunc, colName: string) {
   if (col.semType === DG.SEMTYPE.MACROMOLECULE) {
     const msg = `Negative test detected semType='${col.semType}', units='${col.getTag(DG.TAGS.UNITS)}'.`;
     throw new Error(msg);
-    // col.semType = '';
-    // col.setTag(DG.TAGS.UNITS, '');
-    // col.setTag(NOTATION.SEPARATOR, '');
   }
 }
 
 export async function _testPos(
   readDf: DfReaderFunc, colName: string, units: string,
   aligned: string | null, alphabet: string | null, alphabetSize: number, alphabetIsMultichar: boolean,
-  separator: string | null = null
+  separator: string | null = null,
 ) {
   const df: DG.DataFrame = await readDf();
   const col: DG.Column = df.col(colName)!;
@@ -411,7 +406,7 @@ export async function _testPos(
   if (separator)
     expect(col.getTag(bioTAGS.separator), separator);
 
-  const uh = new UnitsHandler(col);
+  const uh = UnitsHandler.getOrCreate(col);
   expect(uh.getAlphabetSize(), alphabetSize);
   expect(uh.getAlphabetIsMultichar(), alphabetIsMultichar);
   if (!uh.isHelm()) {
@@ -427,7 +422,7 @@ class PosCol {
     public readonly alphabet: string | null,
     public readonly alphabetSize: number,
     public readonly alphabetIsMultichar: boolean,
-    public readonly separator?: string
+    public readonly separator?: string,
   ) { };
 }
 

package/src/tests/detectors-weak-and-likely-tests.ts

@@ -2,7 +2,7 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
+import {category, test} from '@datagrok-libraries/utils/src/test';
 import {ALIGNMENT, ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {_testNeg, _testPos} from './detectors-tests';
 import {DfReaderFunc} from './types';
@@ -31,61 +31,51 @@ category('detectors:weak-and-likely', () => {
 1,TTTTT
 2,TTTTT
 3,TTTTT
-4,TTTTT
-`,
+4,TTTTT`,
     [csvTests.fastaDnaWeak1LikelyName]: `id,seq
 1,TTTTT
 2,TTTTT
 3,TTTTT
-4,TTTTT
-`,
+4,TTTTT`,
     [csvTests.fastaRnaWeak1]: `id,colName
 1,UUUUU
 2,UUUUU
 3,UUUUU
-4,UUUUU
-`,
+4,UUUUU`,
     [csvTests.fastaRnaWeak1LikelyName]: `id,seq
 1,UUUUU
 2,UUUUU
 3,UUUUU
-4,UUUUU
-`,
+4,UUUUU`,
     [csvTests.fastaPtWeak1]: `id,colName
 1,SLSLSPGK
 2,SLSLSPGK
 3,SLSLSPGK
-4,SLSLSPGK
-`,
+4,SLSLSPGK`,
     [csvTests.fastaPtWeak1LikelyName]: `id,seq
 1,SLSLSPGK
 2,SLSLSPGK
 3,SLSLSPGK
-4,SLSLSPGK
-`,
+4,SLSLSPGK`,
     [csvTests.fastaUn1]: `id,colName
 1,word
 2,other
 3,some
-4,another
-`,
+4,another`,
     [csvTests.fastaUn1LikelyName]: `id,seq
 1,word
 2,other
 3,some
-4,another
-`,
+4,another`,
     [csvTests.fastaUn2LikelyName]: `protein
 Boombastic
 Megafantastic
-"just-a-random-thought,oy!"
-`,
+"just-a-random-thought,oy!"`,
     [csvTests.fastaUnMsa1LikelyName]: `id,seq
 1,word
 2,male
 3,bare
-4,core
-`,
+4,core`,
   };
 
   const readCsv: (key: csvTests) => DfReaderFunc = (key: keyof typeof csvData) => {

package/src/tests/fasta-export-tests.ts

@@ -47,7 +47,7 @@ MDYKETLLMP
 KTDFPMRGGL
 >3
 P
-`
+`,
     },
     [SaveAsFastaTests.test2]: {
       srcCsv: `id,id2,seq
@@ -66,8 +66,8 @@ KTDFP
 MRGGL
 >seqC|3
 [MeA]
-`
-    }
+`,
+    },
   };
 
   test('wrapSequenceSingle', async () => {

package/src/tests/fasta-handler-test.ts

@@ -5,7 +5,6 @@ import * as DG from 'datagrok-api/dg';
 
 import {category, expectArray, test} from '@datagrok-libraries/utils/src/test';
 import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 
 category('fastaFileHandler', () => {
@@ -71,7 +70,7 @@ YHSPFHN
   const descriptionsArray = [
     'description:1', 'description:2', 'description:3', 'description:4',
   ];
-  const descriptionCol = DG.Column.fromStrings('description', descriptionsArray);
+  const _descriptionCol = DG.Column.fromStrings('description', descriptionsArray);
 
   const sequencesArray = [
     'MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW',
@@ -86,7 +85,7 @@ YHSPFHN
     const parsedSequencesArray = ffh.sequencesArray;
     expectArray(
       [parsedDescriptionsArray, parsedSequencesArray],
-      [descriptionsArray, sequencesArray]
+      [descriptionsArray, sequencesArray],
     );
   }
 

package/src/tests/lib-tests.ts

@@ -3,11 +3,9 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {category, expectArray, test} from '@datagrok-libraries/utils/src/test';
-import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {category} from '@datagrok-libraries/utils/src/test';
 
-category('monomer lib', () => { 
+category('monomer lib', () => {
   //   test('monomerManager', async() => {
   //   const df: DG.DataFrame = DG.DataFrame.fromCsv(await _package.files.readAsText('tests/test.csv'));
   //   grok.shell.addTableView(df);

package/src/tests/mm-distance-tests.ts

@@ -60,63 +60,67 @@ category('Distance', async () => {
 
   test('levenstein-sub', async () => {
     const df = mmDistanceFunctions[MmDistanceFunctionsNames.LEVENSHTEIN]();
-    _testDistance(prot1, prot2, df, 1);
+    _testDistance(prot1, prot2, df, 0.2);
   });
   test('levenstein-del', async () => {
     const df = mmDistanceFunctions[MmDistanceFunctionsNames.LEVENSHTEIN]();
-    _testDistance(prot3, prot4, df, 2);
+    _testDistance(prot3, prot4, df, 0.4);
   });
 
   test('hamming', async () => {
     const df = mmDistanceFunctions[MmDistanceFunctionsNames.HAMMING]();
-    _testDistance(prot3, prot4, df, 3);
+    _testDistance(prot3, prot4, df, 0.6);
   });
 
   // Note that here the result is actually an inverted value of alignment score, which is coorelated with distance
   // tests using default BLOSUM62 matrix are in agreement with the results of the online tool
   test('needleman-blosum62', async () => {
     const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH]();
-    _testDistance(prot1, prot2, df, -35);
+    _testDistance(prot1, prot2, df, 0.205);
   });
 
   test('needleman-blosum62-del', async () => {
     const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH]();
-    _testDistance(prot3, prot4, df, -14);
+    _testDistance(prot3, prot4, df, 0.65);
   });
 
   test('needleman-custom-sub', async () => {
     const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH](
-      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 1}
+      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 1},
     );
-    _testDistance(prot1, prot2, df, -4);
+    _testDistance(prot1, prot2, df, 0.2);
   });
 
   test('needleman-custom-del', async () => {
     const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH](
-      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 1}
+      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 1},
     );
-    _testDistance(prot3, prot4, df, -1);
+    _testDistance(prot3, prot4, df, 0.8);
   });
 
   test('needleman-custom-zero-extend', async () => {
     const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH](
-      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 0}
+      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 0},
     );
-    _testDistance(prot5, prot6, df, -2);
+    _testDistance(prot5, prot6, df, 0.714);
   });
 
   test('needleman-custom-half-extend', async () => {
     const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH](
-      {scoringMatrix, alphabetIndexes, gapOpen: 2, gapExtend: 1}
+      {scoringMatrix, alphabetIndexes, gapOpen: 2, gapExtend: 1},
     );
-    _testDistance(prot5, prot6, df, 2);
+    _testDistance(prot5, prot6, df, 1.286);
   });
 
   test('needleman-custom-same-extend', async () => {
     const df = mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH](
-      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 1}
+      {scoringMatrix, alphabetIndexes, gapOpen: 1, gapExtend: 1},
     );
-    _testDistance(prot5, prot6, df, 1);
+    if (DG.Test.isInBenchmark) {
+      const seq1 = Array(10000).fill('FWRY').join('');
+      const seq2 = Array(10000).fill('FYWRRY').join('');
+      _testDistance(seq1, seq2, df, 0.667);
+    } else { _testDistance(prot5, prot6, df, 1.143); }
   });
 });
 
@@ -128,11 +132,15 @@ async function _initMacromoleculeColumn(csv: string): Promise<UnitsHandler> {
   if (semType)
     seqCol.semType = semType;
   await grok.data.detectSemanticTypes(srcDf);
-  const uh = new UnitsHandler(seqCol);
+  const uh = UnitsHandler.getOrCreate(seqCol);
   return uh;
 }
 
 function _testDistance(seq1: string, seq2: string, df: (a: string, b: string) => number, expected: number) {
   const d = df(seq1, seq2);
-  expect(d, expected);
+  expect(Number(d.toFixed(3)), Number(expected.toFixed(3)));
+}
+
+export function mapToFixed(ar: Float32Array | number[]) {
+  return Array.from(ar).map((d) => Number(d.toFixed(3)));
 }

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

@@ -29,6 +29,6 @@ category('monomerLibraries', () => {
 
     // Currently default monomer lib set is of all files at LIB_PATH (at least HELMCoreLibrary.json)
     const currentMonomerLib = monomerLibHelper.getBioLib();
-    expect(currentMonomerLib.getTypes().length > 0, true);
+    expect(currentMonomerLib.getPolymerTypes().length > 0, true);
   });
 });

package/src/tests/msa-tests.ts

@@ -6,6 +6,7 @@ import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {runKalign} from '../utils/multiple-sequence-alignment';
 import {multipleSequenceAlignmentUI} from '../utils/multiple-sequence-alignment-ui';
+import {awaitContainerStart} from './utils';
 //import * as grok from 'datagrok-api/grok';
 
 export const _package = new DG.Package();
@@ -75,31 +76,33 @@ MWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHP
 
   test('isCorrect', async () => {
     await _testMsaIsCorrect(fromCsv, toCsv);
-  });
+  }, {skipReason: 'GROK-13221'});
 
   test('isCorrectLong', async () => {
     await _testMsaIsCorrect(longFromCsv, longToCsv);
-  });
+  }, {skipReason: 'GROK-13221'});
 
   test('isCorrectHelm', async () => {
+    await awaitContainerStart();
     await _testMSAOnColumn(helmFromCsv, helmToCsv, NOTATION.HELM, NOTATION.SEPARATOR, undefined, 'mafft');
-  }, {skipReason: 'GROK-13053'});
+  }, {skipReason: 'GROK-13221'});
 
   test('isCorrectHelmLong', async () => {
+    await awaitContainerStart();
     await _testMSAOnColumn(longHelmFromCsv, longHelmToCsv, NOTATION.HELM, NOTATION.SEPARATOR, undefined, 'mafft');
-  }, {skipReason: 'GROK-13053'});
+  }, {skipReason: 'GROK-13221'});
 
   test('isCorrectSeparator', async () => {
     await _testMSAOnColumn(
-      SeparatorFromCsv, SeparatorToCsv, NOTATION.SEPARATOR, NOTATION.FASTA, ALPHABET.PT
+      SeparatorFromCsv, SeparatorToCsv, NOTATION.SEPARATOR, NOTATION.FASTA, ALPHABET.PT,
     );
-  });
+  }, {skipReason: 'GROK-13221'});
 
   test('isCorrectSeparatorLong', async () => {
     await _testMSAOnColumn(
-      SeparatorLongFromCsv, SeparatorLongToCsv, NOTATION.SEPARATOR, NOTATION.FASTA, ALPHABET.PT
+      SeparatorLongFromCsv, SeparatorLongToCsv, NOTATION.SEPARATOR, NOTATION.FASTA, ALPHABET.PT,
     );
-  });
+  }, {skipReason: 'GROK-13221'});
 });
 
 async function _testMsaIsCorrect(srcCsv: string, tgtCsv: string): Promise<void> {
@@ -119,7 +122,7 @@ async function _testMsaIsCorrect(srcCsv: string, tgtCsv: string): Promise<void>
 
 async function _testMSAOnColumn(
   srcCsv: string, tgtCsv: string,
-  srcNotation: NOTATION, tgtNotation: NOTATION, alphabet?: ALPHABET, pepseaMethod?: string
+  srcNotation: NOTATION, tgtNotation: NOTATION, alphabet?: ALPHABET, pepseaMethod?: string,
 ): Promise<void> {
   const srcDf: DG.DataFrame = DG.DataFrame.fromCsv(srcCsv);
   const tgtDf: DG.DataFrame = DG.DataFrame.fromCsv(tgtCsv);

package/src/tests/pepsea-tests.ts

@@ -2,6 +2,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {category, expect, test} from '@datagrok-libraries/utils/src/test';
 import {runPepsea} from '../utils/pepsea';
+import {awaitContainerStart} from './utils';
 
 category('PepSeA', () => {
   const testCsv = `HELM,MSA
@@ -12,10 +13,12 @@ category('PepSeA', () => {
   "PEPTIDE1{F.V.R.G.Y.[MeF].Y.W.S.N.C}$$$$","F.V.R.G.Y.MeF.Y.W.S..N.C"`;
 
   test('Basic alignment', async () => {
+    await awaitContainerStart();
     const table = DG.DataFrame.fromCsv(testCsv);
     const alignedCol = await runPepsea(table.getCol('HELM'), 'msa(HELM)');
+    expect(alignedCol !== null, true, 'PepSeA conainter has not started');
     const alignedTestCol = table.getCol('MSA');
-    for (let i = 0; i < alignedCol.length; ++i)
-      expect(alignedCol.get(i) == alignedTestCol.get(i), true);
-  }, {skipReason: 'GROK-12764'});
+    for (let i = 0; i < alignedCol!.length; ++i)
+      expect(alignedCol!.get(i) == alignedTestCol.get(i), true);
+  }, {skipReason: 'GROK-13221'});
 });