@datagrok/bio 2.11.29 → 2.11.33

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

@@ -1,14 +1,20 @@
-import * as DG from 'datagrok-api/dg';
 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, delay, testEvent} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, test, expect, delay, testEvent, awaitCheck} from '@datagrok-libraries/utils/src/test';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
-  LibSettings, getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
 import {awaitGrid, readDataframe} from './utils';
-import {BioSubstructureFilter, HelmFilter, SeparatorFilter} from '../widgets/bio-substructure-filter';
+import {
+  BioSubstructureFilter, FastaBioFilter, SeparatorBioFilter, SeparatorFilterProps
+} from '../widgets/bio-substructure-filter';
+import {BioFilterProps} from '../widgets/bio-substructure-filter-types';
+import {HelmBioFilter} from '../widgets/bio-substructure-filter-helm';
 
 import {_package} from '../package-test';
 
@@ -16,7 +22,7 @@ import {_package} from '../package-test';
 category('substructureFilters', async () => {
   let monomerLibHelper: IMonomerLibHelper;
   /** Backup actual user's monomer libraries settings */
-  let userLibSettings: LibSettings;
+  let userLibSettings: UserLibSettings;
 
   before(async () => {
     monomerLibHelper = await getMonomerLibHelper();
@@ -34,17 +40,29 @@ category('substructureFilters', async () => {
   });
 
   test('fasta', async () => {
-    const fasta = await readDataframe('tests/filter_FASTA.csv');
+    const df = await readDataframe('tests/filter_FASTA.csv');
+    await grok.data.detectSemanticTypes(df);
+
+    const fSubStr: string = 'MD';
+    const fTrueCount: number = 3;
+
     const filter = new BioSubstructureFilter();
-    await grok.data.detectSemanticTypes(fasta);
-    filter.attach(fasta);
-    filter.bioFilter!.substructure = 'MD';
-    await delay(100);
-    expect(filter.dataFrame!.filter.trueCount, 3);
-    expect(filter.dataFrame!.filter.get(0), true);
-    expect(filter.dataFrame!.filter.get(3), true);
-    expect(filter.dataFrame!.filter.get(8), true);
-    expect(filter.dataFrame!.filter.get(1), false);
+    filter.attach(df);
+    await filter.awaitRendered();
+    try {
+      expect(!!filter.bioFilter, true);
+      expect(filter.bioFilter!.type, 'FastaBioFilter');
+      const bf = filter.bioFilter as FastaBioFilter;
+
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf.props = new BioFilterProps(fSubStr);
+      }, 5000, 'testEvent onRowsFiltered');
+      expect(filter.dataFrame!.filter.trueCount, fTrueCount);
+      expect(filter.dataFrame?.filter.toBinaryString(), '10010000100000');
+    } finally {
+      filter.detach();
+    }
+    await filter.awaitRendered();
   });
 
   test('separator', async () => {
@@ -52,49 +70,254 @@ category('substructureFilters', async () => {
     const filter = new BioSubstructureFilter();
     await grok.data.detectSemanticTypes(msa);
     filter.attach(msa);
-    filter.bioFilter!.substructure = 'meI';
-    await delay(100);
-    expect(filter.dataFrame!.filter.trueCount, 7);
-    expect(filter.dataFrame!.filter.get(2), false);
-    filter.bioFilter!.substructure = '/meI';
-    await delay(100);
-    expect(filter.dataFrame!.filter.trueCount, 0);
-    filter.bioFilter!.substructure = 'meI-hHis';
-    (filter.bioFilter! as SeparatorFilter).separatorInput.value = '-';
-    await delay(100);
-    expect(filter.dataFrame!.filter.trueCount, 7);
-    expect(filter.dataFrame!.filter.get(2), false);
+    await filter.awaitRendered();
+    try {
+      expect(!!filter.bioFilter, true);
+      expect(filter.bioFilter!.type, 'SeparatorBioFilter');
+      const bf = filter.bioFilter as SeparatorBioFilter;
+
+      await testEvent(msa.onRowsFiltered, () => {}, () => {
+        bf.props = new SeparatorFilterProps('meI');
+      }, 5000, 'testEvent onRowsFiltered');
+      expect(filter.dataFrame!.filter.trueCount, 7);
+      expect(filter.dataFrame!.filter.get(2), false);
+
+      await testEvent(msa.onRowsFiltered, () => {}, () => {
+        bf.props = new SeparatorFilterProps('/meI');
+      }, 5000, 'testEvent onRowsFiltered');
+      expect(filter.dataFrame!.filter.trueCount, 0);
+
+      await testEvent(msa.onRowsFiltered, () => {}, () => {
+        bf.props = new SeparatorFilterProps('meI-hHis', '-');
+      }, 5000, 'testEvent onRowsFiltered');
+      expect(filter.dataFrame!.filter.trueCount, 7);
+      expect(filter.dataFrame!.filter.get(2), false);
+    } finally {
+      filter.detach();
+    }
+    await filter.awaitRendered();
   });
 
-  test('helm', async () => {
-    const helm = await readDataframe('tests/filter_HELM.csv');
-    const helmTableView = grok.shell.addTableView(helm);
+  // test('helm', async () => {
+  //   const df = await readDataframe('tests/filter_HELM.csv');
+  //   await grok.data.detectSemanticTypes(df);
+  //   const view = grok.shell.addTableView(df);
+  //
+  //   // // Helm filter calls waitForElementInDom
+  //   // const fg = view.getFiltersGroup({createDefaultFilters: false});
+  //   // _package.logger.debug('Bio tests: substructureFilters/helm, filter attaching.');
+  //   // const filter = new BioSubstructureFilter();
+  //   // filter.attach(df);
+  //   // _package.logger.debug('Bio tests: substructureFilters/helm, filter attached.');
+  //   // const fg = await df.plot.fromType(DG.VIEWER.FILTERS, {
+  //   //   filters: [
+  //   //     {type: 'Bio:bioSubstructureFilter', column: 'HELM string'}]
+  //   // }) as DG.FilterGroup;
+  //   // const fg2 = view.getFiltersGroup({createDefaultFilters: false});
+  //   const fg = view.getFiltersGroup();
+  //   await awaitCheck(() => fg.filters.length == 1, 'Filter panel has not been created', 3000);
+  //   await awaitGrid(view.grid);
+  //   const filter = fg.filters[0] as BioSubstructureFilter;
+  //   // TODO: Check filter type
+  //
+  //   _package.logger.debug('Bio tests: substructureFilters/helm, filter 1 changing.');
+  //   const bf = filter.bioFilter as HelmBioFilter;
+  //   await delay(1000); // to draw grid and filters
+  //   await bf.awaitRendered();
+  //
+  //   _package.logger.debug('Bio tests: substructureFilters/helm, filter 1 change awaiting.');
+  //   await testEvent(df.onRowsFiltered, () => {}, () => {
+  //     bf.props = new BioFilterProps('PEPTIDE1{C}$$$$V2.0');
+  //   }, 20000);
+  //   _package.logger.debug('Bio tests: substructureFilters/helm, filter 1 changed.');
+  //   expect(filter.dataFrame!.filter.trueCount, 2);
+  //   expect(filter.dataFrame!.filter.get(0), true);
+  //   expect(filter.dataFrame!.filter.get(3), true);
+  //
+  //   _package.logger.debug('Bio tests: substructureFilters/helm, filter 2 changing.');
+  //   await testEvent(df.onRowsFiltered, () => {}, () => {
+  //     bf.props = new BioFilterProps('PEPTIDE1{A.C}$$$$V2.0');
+  //   }, 20000);
+  //   await awaitGrid(view.grid);
+  //   _package.logger.debug('Bio tests: substructureFilters/helm, filter 2 changed.');
+  //   expect(filter.dataFrame!.filter.trueCount, 1);
+  //   expect(filter.dataFrame!.filter.get(3), true);
+  // }, {timeout: 30000});
+
+  test('helm-dialog', async () => {
+    const logPrefix = 'Bio tests: substructureFilters/helm-dialog';
+    const df = await readDataframe('tests/filter_HELM.csv');
+    await grok.data.detectSemanticTypes(df);
+    const view = grok.shell.addTableView(df);
+
+    _package.logger.debug(`${logPrefix}, filter attaching.`);
     const filter = new BioSubstructureFilter();
-    await grok.data.detectSemanticTypes(helm);
-
-    _package.logger.debug('Bio/substructureFilters/helm, filter attaching.');
-    filter.attach(helm);
-    _package.logger.debug('Bio/substructureFilters/helm, filter attached.');
-
-    _package.logger.debug('Bio/substructureFilters/helm, filter 1 changing.');
-    (filter.bioFilter! as HelmFilter).helmSubstructure = 'PEPTIDE1{C}$$$$V2.0';
-
-    _package.logger.debug('Bio/substructureFilters/helm, filter 1 change awaiting.');
-    await testEvent(helm.onRowsFiltered, () => {},
-      () => { filter.bioFilter!.onChanged.next(); }, 20000);
-    _package.logger.debug('Bio/substructureFilters/helm, filter 1 changed.');
-    expect(filter.dataFrame!.filter.trueCount, 2);
-    expect(filter.dataFrame!.filter.get(0), true);
-    expect(filter.dataFrame!.filter.get(3), true);
-
-    _package.logger.debug('Bio/substructureFilters/helm, filter 2 changing.');
-    (filter.bioFilter! as HelmFilter).helmSubstructure = 'PEPTIDE1{A.C}$$$$V2.0';
-    _package.logger.debug('Bio/substructureFilters/helm, filter 2 change awaiting.');
-    await testEvent(helm.onRowsFiltered, () => {},
-      () => { filter.bioFilter!.onChanged.next(); }, 20000);
-    await awaitGrid(helmTableView.grid);
-    _package.logger.debug('Bio/substructureFilters/helm, filter 2 changed.');
-    expect(filter.dataFrame!.filter.trueCount, 1);
-    expect(filter.dataFrame!.filter.get(3), true);
-  }, {timeout: 30000});
+    filter.attach(df);
+    const dlg = ui.dialog('Test filters').add(filter.root).show(); // to waitForElementInDom
+    await filter.awaitRendered();
+    try {
+      const bf = filter.bioFilter as HelmBioFilter;
+      expect(filter.bioFilter !== null, true, 'bioFilter is not created');
+
+      // filter 1
+      _package.logger.debug(`${logPrefix}, filter 1 change awaiting...`);
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf.props = new BioFilterProps('PEPTIDE1{A.C}$$$$V2.0');
+      }, 20000);
+      _package.logger.debug(`${logPrefix}, filter 1 changed.`);
+      expect(filter.dataFrame!.filter.trueCount, 1);
+      expect(filter.dataFrame!.filter.toBinaryString(), '0001');
+
+      // filter 2
+      _package.logger.debug(`${logPrefix}, filter 2 change awaiting...`);
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf.props = new BioFilterProps('PEPTIDE1{C}$$$$V2.0');
+      }, 20000);
+      await awaitGrid(view.grid);
+      _package.logger.debug(`${logPrefix}, filter 2 changed.`);
+      expect(filter.dataFrame!.filter.trueCount, 2);
+      expect(filter.dataFrame!.filter.toBinaryString(), '1001');
+    } finally {
+      dlg.close();
+    }
+    await filter.awaitRendered();
+  });
+
+  // Generates unhandled exception accessing isFiltering before bioFilter created
+  test('helm-view', async () => {
+    const logPrefix = 'Bio tests: substructureFilters/helm-view';
+    const df = await readDataframe('tests/filter_HELM.csv');
+    const col = df.getCol('HELM string');
+    await grok.data.detectSemanticTypes(df);
+    const view = grok.shell.addTableView(df);
+
+    const fg = view.getFiltersGroup();
+
+    // await awaitCheck(() => fg.filters.length == 1, 'await filters.length == 1', 1000);
+    // const filter = fg.filters.filter((f) => f.columnName == col.name)[0] as BioSubstructureFilter;
+    await awaitGrid(view.grid);
+  });
+
+  test('sync-fasta', async () => {
+    const df = await _package.files.readCsv('tests/filter_FASTA.csv');
+    await grok.data.detectSemanticTypes(df);
+
+    const fSubStr: string = 'MD';
+    const fTrueCount: number = 3;
+
+    const f1 = await createFilter('fasta', df);
+    const f2 = await createFilter('fasta', df);
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+    try {
+      expect(!!f1.bioFilter, true);
+      expect(!!f2.bioFilter, true);
+      expect(f1.bioFilter!.type, 'FastaBioFilter');
+      expect(f2.bioFilter!.type, 'FastaBioFilter');
+      const bf1 = f1.bioFilter as FastaBioFilter;
+      const bf2 = f2.bioFilter as FastaBioFilter;
+
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf1.props = new BioFilterProps(fSubStr);
+      }, 10000, 'await onRowsFiltered');
+      expect(df.filter.trueCount, fTrueCount);
+
+      await f1.awaitRendered();
+      expect(bf2.props.substructure, fSubStr);
+    } finally {
+      f1.detach();
+      f2.detach();
+    }
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+  });
+
+  // MSA filter has the second input field for separator
+  test('sync-msa', async () => {
+    const df = await _package.files.readCsv('tests/filter_MSA.csv');
+    await grok.data.detectSemanticTypes(df);
+
+    const fSubStr: string = 'hHis-Aca';
+    const fSepStr: string = '-';
+    const fTrueCount: number = 8;
+
+    const f1 = await createFilter('MSA', df);
+    const f2 = await createFilter('MSA', df);
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+    try {
+      expect(!!f1.bioFilter, true);
+      expect(!!f2.bioFilter, true);
+      expect(f1.bioFilter!.type, 'SeparatorBioFilter');
+      expect(f2.bioFilter!.type, 'SeparatorBioFilter');
+      const bf1 = f1.bioFilter as SeparatorBioFilter;
+      const bf2 = f2.bioFilter as SeparatorBioFilter;
+
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf1.props = new SeparatorFilterProps(fSubStr, fSepStr);
+      }, 10000, 'await onRowsFiltered');
+      expect(df.filter.trueCount, fTrueCount);
+
+      expect(bf2.props.substructure, fSubStr);
+      expect(bf2.props.separator, fSepStr);
+    } finally {
+      f1.detach();
+      f2.detach();
+    }
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+  });
+
+  test('sync-helm', async () => {
+    const df = await _package.files.readCsv('tests/filter_HELM.csv');
+    await grok.data.detectSemanticTypes(df);
+    const view = grok.shell.addTableView(df);
+
+    const fSubStr: string = 'PEPTIDE1{A.C}$$$$V2.0';
+    const fTrueCount: number = 1;
+
+    const f1 = await createFilter('HELM string', df);
+    const f2 = await createFilter('HELM string', df);
+    const dlg = ui.dialog('Test filters').add(f1.root).add(f2.root).show(); // to waitForElementInDom
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+    try {
+      expect(!!f1.bioFilter, true);
+      expect(!!f2.bioFilter, true);
+      expect(f1.bioFilter!.type, 'HelmBioFilter');
+      expect(f2.bioFilter!.type, 'HelmBioFilter');
+      const bf1 = f1.bioFilter as HelmBioFilter;
+      const bf2 = f2.bioFilter as HelmBioFilter;
+
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf1.props = new BioFilterProps(fSubStr);
+      }, 60000, 'await onRowsFiltered'); // wait to load monomers
+      await awaitGrid(view.grid);
+      //debugger;
+
+      _package.logger.debug('Bio tests: substructureFilters/sync-helm, before changed event');
+      await delay(f1.debounceTime * 2);
+      _package.logger.debug('Bio tests: substructureFilters/sync-helm, after changed event');
+      expect(df.filter.trueCount, fTrueCount);
+
+      await f1.awaitRendered();
+      expect(bf2.props.substructure, fSubStr);
+    } finally {
+      f1.detach();
+      f2.detach();
+      dlg.close();
+    }
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+    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();
+  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

@@ -11,8 +11,9 @@ import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
 import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
-  getUserLibSettings, LibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 import {toAtomicLevel} from '../package';
@@ -21,22 +22,30 @@ import {_package} from '../package-test';
 const appPath = 'System:AppData/Bio';
 const fileSource = new DG.FileSource(appPath);
 
-const testNames: { [k: string]: string } = {
-  PT: 'peptides-fasta',
-  DNA: 'dna-fasta',
-  MSA: 'msa-separator',
-};
-
-const inputPath: { [k: string]: string } = {
-  PT: 'tests/to-atomic-level-peptides-fasta-input.csv',
-  DNA: 'tests/to-atomic-level-dna-fasta-input.csv',
-  MSA: 'tests/to-atomic-level-msa-separator-input.csv',
-};
+const enum Tests {
+  PT = 'peptides-fasta',
+  DNA = 'dna-fasta',
+  MSA_SEPARATOR = 'msa-separator',
+  MSA_FASTA = 'msa-fasta',
+}
 
-const outputPath: { [k: string]: string } = {
-  PT: 'tests/to-atomic-level-peptides-fasta-output.csv',
-  DNA: 'tests/to-atomic-level-dna-fasta-output.csv',
-  MSA: 'tests/to-atomic-level-msa-separator-output.csv',
+const TestsData: { [testName: string]: { inPath: string, outPath: string } } = {
+  [Tests.PT]: {
+    inPath: 'tests/to-atomic-level-peptides-fasta-input.csv',
+    outPath: 'tests/to-atomic-level-peptides-fasta-output.csv'
+  },
+  [Tests.DNA]: {
+    inPath: 'tests/to-atomic-level-dna-fasta-input.csv',
+    outPath: 'tests/to-atomic-level-dna-fasta-output.csv'
+  },
+  [Tests.MSA_SEPARATOR]: {
+    inPath: 'tests/to-atomic-level-msa-separator-input.csv',
+    outPath: 'tests/to-atomic-level-msa-separator-output.csv'
+  },
+  [Tests.MSA_FASTA]: {
+    inPath: 'tests/to-atomic-level-msa-fasta-input.csv',
+    outPath: 'tests/to-atomic-level-msa-fasta-output.csv'
+  },
 };
 
 const inputColName = 'sequence';
@@ -48,7 +57,7 @@ category('toAtomicLevel', async () => {
 
   let monomerLibHelper: IMonomerLibHelper;
   /** Backup actual user's monomer libraries settings */
-  let userLibSettings: LibSettings;
+  let userLibSettings: UserLibSettings;
 
   before(async () => {
     monomerLibHelper = await getMonomerLibHelper();
@@ -57,10 +66,12 @@ category('toAtomicLevel', async () => {
     await setUserLibSettingsForTests();
     await monomerLibHelper.loadLibraries(true);
 
-    for (const key in testNames) {
-      sourceDf[key] = DG.DataFrame.fromCsv((await fileSource.readAsText(inputPath[key])).replace(/\n$/, ''));
-      await grok.data.detectSemanticTypes(sourceDf[key]);
-      targetDf[key] = DG.DataFrame.fromCsv((await fileSource.readAsText(outputPath[key])).replace(/\n$/, ''));
+    for (const [testName, testData] of Object.entries(TestsData)) {
+      const inputPath = testData.inPath;
+
+      sourceDf[testName] = DG.DataFrame.fromCsv((await fileSource.readAsText(testData.inPath)).replace(/\n$/, ''));
+      await grok.data.detectSemanticTypes(sourceDf[testName]);
+      targetDf[testName] = DG.DataFrame.fromCsv((await fileSource.readAsText(testData.outPath)).replace(/\n$/, ''));
     }
   });
 
@@ -79,9 +90,9 @@ category('toAtomicLevel', async () => {
     expectArray(obtainedArray, expectedArray);
   }
 
-  for (const key in testNames) {
-    test(`${testNames[key]}`, async () => {
-      await getTestResult(sourceDf[key], targetDf[key]);
+  for (const [testName, testData] of Object.entries(TestsData)) {
+    test(`${testName}`, async () => {
+      await getTestResult(sourceDf[testName], targetDf[testName]);
     });
   }
 

package/src/tests/utils/sequences-generators.ts

@@ -1,8 +1,11 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {awaitCheck} from '@datagrok-libraries/utils/src/test';
+import {expect} from '@datagrok-libraries/utils/src/test';
+
+import {awaitGrid} from '../utils';
 
 
 export function generateManySequences(): DG.Column[] {
@@ -32,8 +35,8 @@ export async function performanceTest(generateFunc: () => DG.Column[], testName:
   const col: DG.Column = df.columns.byName('MSA');
   const view: DG.TableView = grok.shell.addTableView(df);
 
-  await awaitCheck(() => { return view.grid.dataFrame !== df; },
-    'View grid has wrong data frame ', 100);
+  await awaitGrid(view.grid);
+  expect(view.grid.dataFrame.id, df.id);
 
   const endTime: number = Date.now();
   const elapsedTime: number = endTime - startTime;

package/src/tests/utils.ts

@@ -3,6 +3,8 @@ import * as grok from 'datagrok-api/grok';
 
 import {delay, expect, testEvent} from '@datagrok-libraries/utils/src/test';
 
+import {startDockerContainer} from '../utils/docker';
+
 import {_package} from '../package-test';
 
 export async function loadFileAsText(name: string): Promise<string> {
@@ -34,12 +36,10 @@ export function _testTableIsNotEmpty(table: DG.DataFrame): void {
 
 /** Waits if container is not started
  * @param {number} ms - time to wait in milliseconds */
-export async function awaitContainerStart(ms: number = 10000): Promise<void> {
-  const container = await grok.dapi.docker.dockerContainers.filter('bio').first();
-  if (container.status !== 'started' && container.status !== 'checking')
-    await delay(ms);
-    // TODO: Enable with new JS API version
-    // await grok.dapi.docker.dockerContainers.run(container.id, true);
+export async function awaitContainerStart(ms: number = 30000): Promise<void> {
+  const dc = await grok.dapi.docker.dockerContainers.filter('bio').first();
+  const dcId = dc.id;
+  await startDockerContainer(dcId, ms);
 }
 
 export async function awaitGrid(grid: DG.Grid, timeout: number = 5000): Promise<void> {

package/src/utils/docker.ts

@@ -0,0 +1,36 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {delay} from '@datagrok-libraries/utils/src/test';
+
+export async function startDockerContainer(dcId: string, timeout: number = 30000): Promise<void> {
+  // TODO: Use the new dockerContainers API
+  const res = await grok.dapi.docker.dockerContainers.run(dcId /*, true */);
+  let end: boolean = false;
+  for (let i = 0; i < timeout / 200; ++i) {
+    const dc = await grok.dapi.docker.dockerContainers.find(dcId);
+    switch (dc.status) {
+      case 'stopped': {
+        await grok.dapi.docker.dockerContainers.run(dcId);
+        break;
+      }
+      case 'pending change':
+      case 'changing': {
+        // skip to wait
+        break;
+      }
+      case 'checking':
+      case 'started': {
+        end = true;
+        break;
+      }
+      case 'error': {
+        throw new Error('Docker container error state.');
+      }
+    }
+    if (end) break;
+    await delay(200);
+  }
+  if (!end) throw new Error('Docker container run timeout.');
+  // this.dc = await grok.dapi.docker.dockerContainers.find(dcId);
+}

package/src/utils/helm-to-molfile.ts

@@ -5,11 +5,11 @@ import * as DG from 'datagrok-api/dg';
 
 import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
 import {MolfileHandlerBase} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler-base';
-import {RDMol, RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {HELM_POLYMER_TYPE, HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 
-import {MonomerLibHelper} from './monomer-lib';
+import {MonomerLibManager} from './monomer-lib/lib-manager';
 
 import {_package} from '../package';
 
@@ -173,7 +173,7 @@ class MonomerWrapper {
     monomerSymbol: string,
     polymerType: HELM_POLYMER_TYPE,
   ) {
-    const monomerLib = MonomerLibHelper.instance.getBioLib();
+    const monomerLib = MonomerLibManager.instance.getBioLib();
     const monomer = monomerLib.getMonomer(polymerType, monomerSymbol);
     if (!monomer)
       throw new Error(`Monomer ${monomerSymbol} is not found in the library`);